view recipes/wince/dbus.py @ 386:ffa86312ee81 treepkg-status

added classed for treepkg status xml generation
author Bjoern Ricks <bricks@intevation.de>
date Wed, 07 Jul 2010 15:40:48 +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 DBus 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",
                              "libexpat-ce-arm-dev"])
    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
export LDFLAGS=-L$MINGWPATH/lib
export CFLAGS=-I$MINGWPATH/include
export CPPFLAGS=-I$MINGWPATH/include

./autogen.sh --enable-maintainer-mode --host=arm-mingw32ce
%(make_dist_command)s
echo "origtargz " %(origtargz)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 configure.in"""
        major = run.capture_output(cmdexpand("/bin/sh -c \"cat configure.in | \
                                             grep dbus_major_version\] | \
                                             awk -F \[ '{print $$3}'\""),
                                             cwd=directory)[:1]
        minor = run.capture_output(cmdexpand("/bin/sh -c \"cat configure.in | \
                                             grep dbus_minor_version\] | \
                                             awk -F \[ '{print $$3}'\""),
                                             cwd=directory)[:1]
        micro = run.capture_output(cmdexpand("/bin/sh -c \"cat configure.in | \
                                             grep dbus_micro_version\] | \
                                             awk -F \[ '{print $$3}'\""),
                                             cwd=directory)[:1]
        if not major or not minor or not micro:
            raise RuntimeError("Could not determine version from \
                                %s/configure.in" % directory)
        return "%s.%s.%s" % (major[:1],minor[:1],micro[:1])
    
    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)