make-ppa

#!/usr/bin/env python

# Creates source packages and uploads them to Launchpad.
#
# Put this script somewhere, then run it from a git repository containing
# sources for a debian package. Resulting packages will be created in a
# subdirectory next to the make-ppa script.

from __future__ import print_function

import sys
import os
import subprocess
import re
import argparse

CHANGELOG = 'debian/changelog'
DISTS = ['trusty', 'xenial', 'bionic', 'focal', 'jammy', 'kinetic']
VERSION_PATTERN = re.compile(
    r'^(?P<name>[+-.a-z0-9]+)\s+\((?P<version>[^)]+)\)\s+(?P<dist>[^)]+); urgency=(?P<urgency>.+)$')
OUTPUT_DIR = os.path.dirname(os.path.abspath(__file__))

if sys.version_info[0] < 3:
    input = raw_input


class Package(object):

    def __init__(self, dists=DISTS, ppa='yubico/stable'):
        self.dists = dists

        file = open(CHANGELOG, 'r')
        self.changelog = file.readlines()
        file.close()
        match = VERSION_PATTERN.match(self.changelog[0])

        self.ppa = ppa
        self.name = match.group('name')
        self.dist = match.group('dist')
        self.urgency = match.group('urgency')
        orig_version = match.group('version')

        base_target = "%s/%s/%s" % (OUTPUT_DIR, self.name, orig_version)
        if '~ppa' in orig_version:
            print("Version '%s %s' already looks like a ppa version!" % \
                (orig_version, self.dist))
            sys.exit(1)

        ppa_version = 1
        while os.path.exists('%s~ppa%d' % (base_target, ppa_version)):
            ppa_version += 1
        self.version = '%s~ppa%s' % (orig_version, ppa_version)
        self.target = "%s/%s/%s" % (OUTPUT_DIR, self.name, self.version)

    def build_dist(self, dist):
        version = '%s~%s1' % (self.version, dist)
        line = "%s (%s) %s; urgency=%s" % \
            (self.name, version, dist, self.urgency)
        print("Build %s" % line)
        changelog = list(self.changelog)
        changelog[0] = line

        file = open(CHANGELOG, 'w')
        file.writelines(changelog)
        file.close()

        os.system('debuild -S -sa -us -uc')
        os.system('mv ../%s_%s* %s/' %
                 (self.name, version, self.target))

    def build(self, install_deps):
        upstream_version = self.version.split('-', 1)[0]
        orig = '%s_%s.orig.tar.gz' % (self.name, upstream_version)
        if not os.path.exists('../%s' % orig):
            try:
                res = subprocess.check_output('pristine-tar list', shell=True)
                if not orig in res.split():
                    print("../%s is missing!" % orig)
                    sys.exit(1)
                os.system('pristine-tar checkout %s' % orig)
                os.system('mv %s ../' % orig)
            except:
                # Try without orig, might be a native package.
                pass

        os.system('mkdir -p %s' % self.target)
        os.system('cp ../%s %s/' % (orig, self.target))

        if install_deps:
            os.system('yes | sudo mk-build-deps --install --remove')

        for dist in self.dists:
            self.build_dist(dist)

        file = open(CHANGELOG, 'w')
        file.writelines(self.changelog)
        file.close()

    def sign(self, key, program):
        args = [
            ("-k %s" % key) if key else "",
            ("-p %s" % program) if program else "",
        ]
        cmd = ('debsign %s %s/%s_%s*_source.changes' %
              (" ".join(args), self.target, self.name, self.version))
        os.system(cmd)

    def upload(self):
        for file in os.listdir(self.target):
            if file.endswith('.changes'):
                os.system('dput ppa:%s %s/%s' % (self.ppa, self.target, file))


if __name__ == '__main__':
    parser = argparse.ArgumentParser('Create source packages for PPA',
                                     add_help=True)
    parser.add_argument('--no-sign', action='store_false', dest='sign',
                        help='Do not sign the packages (implies --no-upload)')
    parser.add_argument('--no-upload', action='store_false', dest='upload',
                        help='Do not upload the (signed) packages')
    parser.add_argument('--dists', nargs='+', default=DISTS, metavar='DIST',
                        help='Distributions to build for')
    parser.add_argument('--ppa', nargs='?', default='yubico/stable',
                        help='PPA to upload to')
    parser.add_argument('--force', action='store_true', dest='force',
                        help='Do not prompt for confirmation before running')
    parser.add_argument('--install-deps', action='store_true', dest='install_deps',
                        help='Install build dependencies')
    parser.add_argument('-k', '--key', nargs='?',
                        help='GPG key id to use for signing')
    parser.add_argument('-p', '--program', nargs='?',
                        help='GPG program to use for signing')

    args = parser.parse_args()

    do_sign = args.sign
    do_upload = do_sign and args.upload

    package = Package(dists=args.dists, ppa=args.ppa)

    print("Building %s %s for distributions: %s" % \
        (package.name, package.version, ', '.join(package.dists)))
    if do_sign:
        print("Will sign packages!")
    if do_upload:
        print("Will upload packages!")
        print("PPA: %s" % args.ppa)
    if not args.force:
        input("Enter to continue, Ctrl+C to abort")

    package.build(args.install_deps)

    if do_sign:
        package.sign(args.key, args.program)

    if do_upload:
        package.upload()

    print("All done!")