view recipes/wince/libexpat.py @ 510:1f04bd88fca3

provide a possibility to use rules from a git repo
author Bjoern Ricks <bricks@intevation.de>
date Tue, 09 Nov 2010 15:26:20 +0000
parents 964e6981847a
children
line wrap: on
line source
# Copyright (C) 2010 by Intevation GmbH
# Authors:
# Andre Heinecke <aheinecke@intevation.de>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Recipe to build libexpat from Git"""

import os
import re
import inspect
import new

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

class SourcePackager(treepkg.packager.SourcePackager):

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

    tarball_dependencies=set(["autoconf", "automake","git-core", "git"])
    createtarball_script = """\
#! /bin/bash
set -e

apt-get --assume-yes --force-yes install %(builddeps)s

# 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/work
cp -a %(basedir)s $workdir
cd $workdir

export MINGWPATH=/opt/mingw32ce
export INCLUDE=$MINGWPATH/arm-mingw32ce/include:$MINGWPATH/include:$INCLUDE
export LIB=$MINGWPATH/arm-mingw32ce/lib:$MINGWPATH/lib:$LIB
export PATH=:$PATH:$MINGWPATH/bin:$MINGWPATH/arm-mingw32ce/bin:\
$MINGWPATH/libexec/gcc/arm-mingw32ce/4.4.0:

autoreconf
./configure --enable-maintainer-mode --host=arm-mingw32ce
%(make_dist_command)s

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

    make_dist_command = "make dist"

    def __init__(self, *args):
        super(SourcePackager, self).__init__(*args)
        self.pkgbasename = None
        self.pkgbaseversion = None
        self.origtargz = None

    def orig_source_version(self, directory):
        """Determines the version from expat.h directory"""
        filename = os.path.join(directory, "conftools/get-version.sh")
        expat_h = os.path.join(directory, "lib/expat.h")
        output = run.capture_output(cmdexpand("$filename $expat_h",**locals()))
        return output
    
    def determine_package_version(self, directory):
        """ Returns a Git package Name """
        date = run.capture_output(cmdexpand("/bin/sh -c \" git log --date=iso \
                                             -n 1 | grep Date \
                                             | awk \'{print $$2}\'\""),
                                             cwd=directory)
        time = run.capture_output(cmdexpand("/bin/sh -c \" git log --date=iso \
                                             -n 1 | grep Date \
                                             | awk \'{print $$3}\'\""),
                                             cwd=directory)
        date = date.replace('-','')
        time = time.replace(':','')
        return "%s-%s%s.%s" % (self.orig_source_version(directory),
                              date[:8], time[:4], self.revision[:7])

    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,
                         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)
        self.track.builder.run_script([script_name],
                                      logfile=os.path.join(self.log_dir,
                                                           "tarball_log.txt"),
                                      bindmounts=[self.work_dir, self.src_dir])

    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 change: %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)
This site is hosted by Intevation GmbH (Datenschutzerklärung und Impressum | Privacy Policy and Imprint)