view recipes/gnupg/base.py @ 565:7de7869962ef

Correct syntax and display abspath of config file
author Bjoern Ricks <bricks@intevation.de>
date Fri, 02 Sep 2011 10:30:52 +0000
parents 3105488b3eab
children
line wrap: on
line source
# Copyright (C) 2007, 2008 by Intevation GmbH
# Authors:
# Bernhard Herzog <bh@intevation.de>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Base classes for all gnupg packagers"""

import os
import re
import inspect
import new
import shutil

import treepkg.util
import treepkg.packager
import treepkg.run as run
from treepkg.cmdexpand import cmdexpand


class BaseSourcePackager(treepkg.packager.SourcePackager):

    def orig_source_version(self, directory):
        """Determines the version from the configure.ac file in directory"""
        filename = os.path.join(directory, "configure.ac")
        for line in open(filename):

            # Matches lines like
            # m4_define(my_version, [1.1.7])
            # used by most of the gnupg packages
            match = re.match(r"m4_define\(\[?my_version\]?, \[([^]]+)\]\)",
                             line)
            if match:
                return match.group(1)

            # Matches lines like.
            # AC_INIT(pinentry, 0.7.6-cvs, [gnupg-devel@gnupg.org])
            # pinentry is the GnuPG package that actually needs this
            match = re.match(r"AC_INIT\([a-zA-Z_]+, ([0-9.]+)", line)
            if match:
                return match.group(1)

        raise RuntimeError("Could not determine the version number from %s"
                           % filename)

    def determine_upstream_version(self, directory=None):
        return self.orig_source_version(directory) 

    def do_package(self):
        pkgbaseversion, pkgbasedir = self.export_sources()

        run.call(cmdexpand("/bin/sh autogen.sh"), cwd=pkgbasedir,
                 suppress_output=True)
        orig_version = self.orig_source_version(pkgbasedir)

        # patch the version number in the newly generated configure
        # file.  autogen.sh normally determines it from svn, but here it
        # ran on a copy that did not include the .svn subdirectories and
        # thus could not find the svn revision.
        #treepkg.util.replace_in_file(os.path.join(pkgbasedir, "configure"),
        #                             re.escape(orig_version) + "-git0",
        #                             orig_version + "-git%s" % self.revision)

        pkgbasename = self.pkg_basename + "_" + pkgbaseversion
        origtargz = os.path.join(self.work_dir,
                                 pkgbasename + ".orig.tar.gz")
        self.create_tarball(origtargz, self.work_dir,
                            os.path.basename(pkgbasedir))

        changemsg = ("Update to git rev. %s" % (self.revision,))
        self.copy_debian_directory(pkgbasedir, pkgbaseversion,
                                   changemsg)

        self.create_source_package(pkgbasedir, origtargz)
        self.move_source_package(pkgbasename)


class SmartSourcePackager(BaseSourcePackager):

    """SourcePackager that uses pbuilder to create the source tarball.

    We try to create source tarballs that are as close to the tarballs
    created by the upstream maintainers as possible.  For the gnupg
    software this means we need to run 'make dist' in a configured SVN
    working copy with some additional software installed like autoconf
    and texinfo.  We want to avoid running code from a working copy
    outside of the pbuilder environment and having to install recipe
    specific additional software packages in the treepkg host system.
    Therefore we create the source tarball using 'pbuilder execute' with
    a script.
    """

    createtarball_script = """\
#! /bin/bash
set -e 

# Check if we are in a scratchbox
if [ -n "${SBOX_UNAME_MACHINE+x}" ]; then
    fakeroot apt-get --assume-yes --force-yes install %(builddeps)s      
else
    apt-get --assume-yes --force-yes install %(builddeps)s
fi
export AUTOMAKE_SUFFIX=-1.10
# copy the source tree to a directory that's under pbuilder control so
# that it gets removed along with the build environment.  Otherwise we
# end up with a directory containing files that cannot be removed by
# treepkg
workdir=/tmp/treepkg_gpg_work
cp -a %(basedir)s $workdir
cd $workdir

# tweak autoconf settings so that make dist produces a tar.gz, not a
# tar.bz2. Removing all options whose names contain 'dist' should
# achieve that.
cp Makefile.am Makefile.am.orig
sed -e '/AUTOMAKE_OPTIONS/ s/[a-zA-Z0-9-]*dist[a-zA-Z0-9-]*//g' \
    Makefile.am.orig > Makefile.am

# Run Autogen
./autogen.sh

# Tweak configure to contain svn revision numbers
cp configure configure.orig
sed -e "s/-svn0/-svn%(svn_revision)s/g" configure.orig > configure

echo ./configure --enable-maintainer-mode $add_cfg_opts
./configure --enable-maintainer-mode

# revert autoconf changes, so that the original Makefile.am ends up in
# the tarball
mv Makefile.am.orig Makefile.am

# Evil hack for a fig2dev bug in scratchbox
fakefigs="gnupg-card-architecture libgcrypt-modules fips-fsm"

if [ -n "${SBOX_UNAME_MACHINE+x}" ]; then
    for i in $fakefigs; do
        if [ -f doc/$i.fig ]; then
            touch doc/$i.eps
            touch doc/$i.png
            touch doc/$i.pdf
        fi
    done
fi

%(make_dist_command)s

mv *.tar.gz %(origtargz)s
"""

    make_dist_command = "make dist"

    def __init__(self, *args):
        super(SmartSourcePackager, self).__init__(*args)
        self.pkgbasename = None
        self.pkgbaseversion = None
        self.origtargz = None
        origbuilder = self.track.builder
        self.builder = PBuilder(origbuilder.builderconfig,
                                origbuilder.root_cmd,
                                origbuilder.release_signing_keyid)

    def copy_workingcopy(self, dest):
        treepkg.util.copytree(self.track.checkout_dir, dest)

    def create_original_tarball(self):
        copied_working_copy = os.path.join(self.work_dir, "copied_working_copy")
        self.copy_workingcopy(copied_working_copy)

        self.pkgbaseversion = \
                            self.determine_package_version(copied_working_copy)
        self.pkgbasename = self.pkg_basename + "_" + self.pkgbaseversion
        self.origtargz = os.path.join(self.work_dir,
                                      self.pkgbasename + ".orig.tar.gz")
        script = (self.createtarball_script
                  % dict(builddeps=" ".join(self.track.dependencies_required()
                                            | self.tarball_dependencies),
                         basedir=copied_working_copy,
                         origtargz=self.origtargz,
                         svn_revision=self.revision,
                         make_dist_command=self.make_dist_command))
        script_name = os.path.join(self.work_dir, "createtarball")
        treepkg.util.writefile(script_name, script, 0755)

        treepkg.util.ensure_directory(self.src_dir)
        treepkg.util.ensure_directory(self.log_dir)
        try:
            self.builder.run_script([script_name],
                                    logfile=os.path.join(self.log_dir, 
                                                         "tarball_log.txt"),
                                    bindmounts=[self.work_dir, self.src_dir])
        finally:
            shutil.rmtree("/tmp/treepkg_gpg_work", ignore_errors=True)

    def create_orig_dir(self):
        """Unpacks the tarball created by create_original_tarball into work_dir
        """
        unpack_dir = os.path.join(self.work_dir, "unpack")
        treepkg.util.ensure_directory(unpack_dir)
        run.call(cmdexpand("tar xzf $origtargz -C $unpack_dir",
                           unpack_dir=unpack_dir, origtargz=self.origtargz))
        unpacked_files = treepkg.util.listdir_abs(unpack_dir)
        if len(unpacked_files) != 1:
            raise RuntimeError("%s should have extracted to a single directory",
                               origtargz)
        unpacked_dir = unpacked_files[0]

        orig_dir = os.path.join(self.work_dir, os.path.basename(unpacked_dir))
        os.rename(unpacked_dir, orig_dir)
        return orig_dir

    def do_package(self):
        self.create_original_tarball()
        orig_dir = self.create_orig_dir()

        changemsg = ("Update to git rev. %s" % (self.revision,))
        self.copy_debian_directory(orig_dir, self.pkgbaseversion, changemsg)

        self.create_source_package(orig_dir, self.origtargz)
        self.move_source_package(self.pkgbasename)


def define_gnupg_packager(pkg_basename,
                          tarball_dependencies=("autoconf", "automake",
                                                "texinfo"),
                          make_dist_command=None):
    """Create a SourcePackager for a GnuPG package in the caller's globals().
    This is a helper function for the modules in the recipe.gnupg package.
    """
    base_class = BaseSourcePackager
    class_attributes = dict(pkg_basename=pkg_basename)
    if tarball_dependencies is not None:
        base_class = SmartSourcePackager
        class_attributes["tarball_dependencies"] = set(tarball_dependencies)
    if make_dist_command is not None:
        base_class = SmartSourcePackager
        class_attributes["make_dist_command"] = make_dist_command

    caller_globals = inspect.currentframe().f_back.f_globals
    caller_globals["SourcePackager"] = new.classobj("SourcePackager",
                                                    (base_class,),
                                                    class_attributes)
This site is hosted by Intevation GmbH (Datenschutzerklärung und Impressum | Privacy Policy and Imprint)