Mercurial > treepkg > treepkg

#! /usr/bin/env python
# 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.

"""
Mock sudo that mimics some aspects of sudo pbuilder invocations for test cases
"""

import sys
import os
import shutil
import tempfile
import re

from optparse import OptionParser

sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir))

from treepkg.util import extract_value_for_key, writefile
from treepkg.run import call
from treepkg.cmdexpand import cmdexpand


def parse_command_line(args):
    if len(args) < 2:
        raise RuntimeError("mocksudopbuilder must be called with at least"
                           " two parameters")
    if args[0] != "/usr/sbin/pbuilder":
        raise RuntimeError("mocksudopbuilder must be called with"
                           " /usr/sbin/pbuilder as first argument")

    cmd = args[1]
    if cmd != "build":
        raise RuntimeError("mocksudopbuilder only supports the pbuilder build"
                           " command")

    args = args[2:]

    parser = OptionParser()
    parser.add_option("--configfile")
    parser.add_option("--logfile")
    parser.add_option("--buildresult")
    parser.add_option("--debbuildopts")

    opts, rest = parser.parse_args(args)
    return opts, rest


class DSC(object):

    def __init__(self, filename):
        self.filename = os.path.abspath(filename)
        self.parse_dsc_file()

    def parse_dsc_file(self):
        lines = open(self.filename).readlines()

        self.source_package = extract_value_for_key(lines, "Source:")

        raw_binaries = extract_value_for_key(lines, "Binary:")
        self.binaries =  [name.strip() for name in raw_binaries.split(",")]

        version = extract_value_for_key(lines, "Version:")
        match = re.match(r"\d+:", version)
        if match:
            version = version[match.end(0):]
        self.version = version
        match = re.search("-([^-]+)$", version)
        if match:
            self.base_version = version[:match.start(0)]
            self.revision = match.group(1)
        else:
            self.base_version = version
            self.revision = ""

        self.files = []
        for i in range(len(lines) - 1, -1, -1):
            line = lines[i]
            if line[0] != " ":
                break
            self.files.append(line.split()[-1])

def unpack_source_pkg(dsc):
    tempdir = tempfile.mkdtemp()
    call(cmdexpand("dpkg-source -x $filename", filename=dsc.filename),
         cwd=tempdir, stdout=sys.stdout)
    return os.path.join(tempdir, dsc.source_package + "-" + dsc.base_version)

def parse_debian_control(filename):
    packages = []
    lines = [line.strip() for line in open(filename).readlines()]
    while lines:
        try:
            empty_line = lines.index("")
        except ValueError:
            empty_line = len(lines)
        paragraph = lines[:empty_line]
        lines = lines[empty_line + 1:]

        package_name = extract_value_for_key(paragraph, "Package:")
        arch = extract_value_for_key(paragraph, "Architecture:")
        if package_name is not None:
            packages.append((package_name, arch))
    return packages

def create_binary_results(buildresult, dsc, packages):
    for name, arch in packages:
        if arch == "any":
            arch = "i386"
        writefile(os.path.join(buildresult,
                               "%s_%s_%s.deb" % (name, dsc.version, arch)),
                  "")

    basename = os.path.splitext(os.path.basename(dsc.filename))[0]
    writefile(os.path.join(buildresult, basename + "_i386.changes"), "")

def create_source_results(buildresult, dsc):
    dscdir = os.path.dirname(dsc.filename)
    shutil.copy(dsc.filename, buildresult)
    for name in dsc.files:
        shutil.copy(os.path.join(dscdir, name), buildresult)

def mock_pbuilder_build(opts, dscfilename):
    dsc = DSC(dscfilename)
    print "unpacking source package"
    unpacked_dir = unpack_source_pkg(dsc)
    try:
        packages = parse_debian_control(os.path.join(unpacked_dir, "debian",
                                                     "control"))
        create_binary_results(opts.buildresult, dsc, packages)
        create_source_results(opts.buildresult, dsc)
    finally:
        print "removing tempdir", repr(os.path.dirname(unpacked_dir))
        shutil.rmtree(os.path.dirname(unpacked_dir))

def main():
    opts, rest = parse_command_line(sys.argv[1:])
    for optname in ["buildresult"]:
        if getattr(opts, optname) is None:
            raise RuntimeError("Missing required option %r" % optname)
    if len(rest) != 1:
        raise RuntimeError("Missing required argument for .dsc file")
    if opts.logfile:
        sys.stdout = open(opts.logfile, "w", 1)
    mock_pbuilder_build(opts, rest[0])

main()
author	Bjoern Ricks <bricks@intevation.de>
date	Fri, 06 Aug 2010 13:28:47 +0000
parents	c0ea6cbb0fd2
children