view test/mocksudopbuilder.py @ 164:a68a4e22549c

Extend treepkg.run.call so that data can be fed to stdin of the subprocess.
author Bernhard Herzog <bh@intevation.de>
date Fri, 20 Jun 2008 14:06:27 +0000
parents 98a7d70746a9
children c0ea6cbb0fd2
line wrap: on
line source
#! /usr/bin/env python
# Copyright (C) 2007 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")

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