dasource

#!/usr/bin/python

"""
Generate the source Debian package from the source checkout using its name.
"""

import dabuildsys
from dabuildsys import BuildError

import argparse
import debian.deb822
import os.path
import re
import shutil
import subprocess
import sys
import tempfile

from functools import partial

class BuildErrorNotReally(BuildError):
    pass

def build_source_package(checkout, dver, uver, allow_overwrite=False, keep_temp=False):
    """Builds a Debian source package given the checkout, the Debian version
    and the upstream version."""

    ucommit, dcommit = checkout.get_build_revisions(uver, dver)

    files = checkout.get_source_filenames(dver, include_extra=True, include_manifest=True)
    files_dst = map(partial(os.path.join, dabuildsys.source_package_dir), files)
    pkgname = "%s-%s" % (checkout.name, uver)

    if not allow_overwrite and any(os.path.exists(f) for f in files_dst if not f.endswith('.tar.gz')):
        raise BuildErrorNotReally("%s already has a built version in source packages directory" % pkgname)

    tmpdir = tempfile.mkdtemp('dabuildsys')
    files_tmp = map(partial(os.path.join, tmpdir), files)
    pkgdir = os.path.join(tmpdir, pkgname)
    origfile = os.path.join(tmpdir, "%s_%s.orig.tar.gz" % (checkout.name, uver))
    manifestfile = os.path.join(tmpdir, "%s_%s.debathena" % (checkout.name, dver))

    print "Attempting to build source package for %s %s" % (checkout.name, dver)
    print "Debian revision: %s" % str(dcommit)
    print "Upstream revision: %s" % str(ucommit)

    if not checkout.native:
        pristine_name = "%s.tar.gz" % re.sub('^debathena-', '', pkgname)
        tar_candidates = [s for s in checkout.list_tarballs() if s.lower().replace('_', '-') == pristine_name.lower()]
        if len(tar_candidates) == 1:
            pristine_name, = tar_candidates
        else:
            raise BuildError("Unable to find the tarball %s using pristine-tar" % pristine_name)
        pristine_path = os.path.join(tmpdir, pristine_name)

        orig_tree = checkout.get_tarball_tree(pristine_name)
        if not orig_tree:
            os.rmdir(tmpdir)
            raise BuildError("Failed to extract %s from pristine-tar" % pristine_name)
        if orig_tree != ucommit.tree:
            os.rmdir(tmpdir)
            raise BuildError("Upstream tarball %s was not generated from upstream commit" % orig_tree)

        checkout.export_tarball(pristine_path)
        os.rename(pristine_path, origfile)
    
    print "Temporary directory: %s" % tmpdir

    os.mkdir(pkgdir)
    dcommit.extract_tree(pkgdir)

    try:
        debuild_out = subprocess.check_output(['debuild', '-S', '-us', '-uc', '-sa', '-i', '-I'],
                stderr = subprocess.STDOUT,
                cwd = pkgdir).strip()
    except subprocess.CalledProcessError as err:
        print >>sys.stderr, "===== BEGIN DEBUILD OUTPUT ====="
        print >>sys.stderr, err.output
        print >>sys.stderr, "===== END DEBUILD OUTPUT ====="
        raise BuildError("debuild exited with return code %i" % err.returncode)

    print
    print "Successfully built the source package"

    # Record the manifest
    with open(manifestfile, "w") as f:
        manifest = debian.deb822.Deb822()
        manifest['Upstream-Version'] = uver
        manifest['Upstream-Commit']  = str(ucommit)
        manifest['Debian-Version']   = dver
        manifest['Debian-Commit']    = str(dcommit)
        f.write(str(manifest))

    for src, dst in zip(files_tmp, files_dst):
        shutil.move(src, dst)

    print "The following files are now in %s:" % dabuildsys.source_package_dir
    for filename in files:
        print "* %s" % filename

    if not keep_temp:
        shutil.rmtree(tmpdir)

def main():
    argparser = argparse.ArgumentParser(description="Build a source package")
    argparser.add_argument("packages", nargs='+', help="List of packages to build")
    argparser.add_argument("--unreleased", "-U", action="store_true", help="Build the last released version if the package is not released")
    argparser.add_argument("--allow-overwrite", action="store_true", help="Overwrite package files if they already exist")
    argparser.add_argument("--keep-temp", action="store_true", help="Keep the temporary directory")
    argparser.add_argument("--update-checkout", "-u", action="store_true", help="Update the checkouts before building")
    args = argparser.parse_args()

    built = []
    failed = []
    skipped = []

    checkouts, _ = dabuildsys.expand_srcname_spec(args.packages, full_clean=args.update_checkout)

    for checkout in checkouts:
        package = checkout.dirname
        try:
            if not checkout.released and not args.unreleased:
                raise BuildError("Package %s is not released, and -u flag is not specified" % package)
            
            version = checkout.released_version
            build_source_package(checkout,
                    version,
                    dabuildsys.extract_upstream_version(version),
                    allow_overwrite=args.allow_overwrite,
                    keep_temp=args.keep_temp)
            built.append(package)
        except Exception as err:
            if isinstance(err, BuildErrorNotReally):
                print "Skipped %s, because already built" % package
                skipped.append(package)
            else:
                print >>sys.stderr, "Failed building %s: %s" % (package, err)
                failed.append(package)

    if built:
        built.sort()
        print "%i packages built successfully: %s" % (len(built), ', '.join(built))
    else:
        print "No packages built successfully"

    if failed:
        failed.sort()
        print "%i packages failed to build: %s" % (len(failed), ', '.join(failed))

    if skipped:
        skipped.sort()
        print "%i packages skipped: %s" % (len(skipped), ', '.join(skipped))

if __name__ == '__main__':
    if not dabuildsys.claim_lock():
        print >>sys.stderr, "The lock is in place; unable to proceed"
        sys.exit(1)
    try:
        main()
    finally:
        dabuildsys.release_lock()