pkg://katana-build-2.0.0-1.noarch.rpm:11897/usr/share/katana/build/stage1.py  info  downloads

import copy
import operator
import os
import zipfile

JARCMD = os.environ.get("JAR", "jar")

class JarList:
    def __init__(self):
        self.jars = []

    def __repr__(self):
        return repr(self.jars)

    def addFromCommandLine(self, args):
        args = copy.copy(args)
        options = global_options = JarFile.Options()
        while args:
            arg = args.pop(0)
            if arg.startswith("--"):
                options.set(arg[2:], args)
            else:
                assert arg.endswith(".jar")
                options = JarFile.Options(global_options)
                self.jars.append(JarFile(arg, options))
        if global_options.get("version") is None:
            global_options.set("version", [os.environ["RPM_PACKAGE_VERSION"]])
        for jar in self.jars:
            jar._post__init__()

    def getBuildCommands(self):
        jars = {}
        for jar in self.jars:
            jars[jar.path] = jar
        paths = jars.keys()
        paths.sort()
        return reduce(operator.add, [
            jars[path].get_build_commands() for path in paths], [])

class JarFile:
    class Options: 
        options = {
            "output":    "string",
            "version":   "string",
            "ignore":    "list",
            "collapse":  "list",
            "merge":     "merge",
            "transform": "string"}

        def __init__(self, parent = None):
            self._parent = parent

        def get(self, option):
            assert self.options.has_key(option)
            if hasattr(self, option):
                return getattr(self, option)
            elif self._parent is not None:
                return self._parent.get(option)
            else:
                return None

        def set(self, option, args):
            getattr(self, "_set_" + self.options[option])(option, args)

        def _set_string(self, option, args):
            assert not hasattr(self, option)
            setattr(self, option, args.pop(0))

        def _set_list(self, option, args):
            if not hasattr(self, option):
                setattr(self, option, [])
            getattr(self, option).append(args.pop(0))

        def _set_merge(self, option, args):
            a, sep, b = (args.pop(0), args.pop(0), args.pop(0))
            assert sep == "--into"
            args.insert(0, (a, b))
            self._set_list(option, args)

    def __init__(self, path, options):
        self.path, self._options = path, options

    def __getattr__(self, attr):
        return self._options.get(attr)

    def __repr__(self):
        return " ".join(
            ["<JarFile", "path=%s" % self.path] +
            ["%s=%s" % (attr, getattr(self, attr))
             for attr in self.Options.options.keys() + ["rejar"]]) + ">"

    def _post__init__(self):
        items = self.ClassHeirachy()
        ignores = [["META-INF", "MANIFEST.MF"]]
        if self.ignore is not None:
            ignores.extend([ignore.split(os.sep) for ignore in self.ignore])
        items.extend([
            item.split(os.sep)
            for item in zipfile.ZipFile(self.path, "r").namelist()
            if not item.endswith(os.sep)], ignores)
        self.packages = items.packages()
        if self.collapse is not None:
            for pkg in self.collapse:
                subpackages = [
                    sub for sub in self.packages if sub.startswith(pkg + ".")]
                assert subpackages
                for sub in subpackages:
                    self.packages.remove(sub)
                self.packages.append(pkg)
        if self.merge is not None:
            for pkg, into in self.merge:
                self.packages.remove(pkg)
        self.rejar = len(self.packages) > 1 or self.ignore or self.merge

    class ClassHeirachy:
        def __init__(self):
            self.items = {}

        def extend(self, items, ignores):
            for item in items:
                self.append(item, ignores)

        def append(self, item, ignores):
            for ignore in ignores:
                if item[:len(ignore)] == ignore:
                    break
            else:
                self.__append(self.items, copy.copy(item))

        def __append(self, items, item):
            key = item.pop(0)
            if item:
                if not items.has_key(key):
                    items[key] = {}
                self.__append(items[key], item)
            else:
                if items.has_key(key):
                    raise RuntimeError, "duplicate entry"
                items[key] = None

        def packages(self):
            return self.__packages(self.items)

        def __packages(self, items):
            packages = []
            for i in items:
                if items is self.items and i == "META-INF":
                    packages.append("META-INF")
                    continue
                for j in items[i]:
                    if items[i][j] is None:
                        packages.append(i)
                        break
                else:
                    packages.extend(
                        ["%s.%s" % (i, package)
                         for package in self.__packages(items[i])])
            return packages

    def get_build_commands(self):
        return self.__get_jar_build_commands() + \
               self.__get_locator_build_commands()

    def __get_jar_build_commands(self):
        if not self.rejar:
            assert len(self.packages) == 1
            return ["cp -p %s %s" % (self.path, os.path.join(
                self.output, "%s-%s.jar" % (
                    self.packages[0], self.version)))]
        tmp = os.path.join(self.output, os.path.split(self.path)[1])
        invtmp = os.sep.join([".." for dir in tmp.split(os.sep)])
        commands = ["mkdir %s" % tmp, "cd %s" % tmp,
                    "%s xf %s" % (JARCMD, os.path.join(invtmp, self.path))]
        extras = ["cd %s" % invtmp, "rm -rf %s" % tmp]
        packages = copy.copy(self.packages)
        packages.sort()
        for pkg in packages:
            if self.merge is not None:
                merges = [merge for merge, into in self.merge if into == pkg]
                merges.sort()
            else:
                merges = []
            commands.append(" ".join([
                JARCMD, "cf", os.path.join(
                    os.path.split(invtmp)[0], "%s-%s.jar" % (pkg,
                                                             self.version))] +
                [name.replace(".", os.sep) for name in [pkg] + merges]))
            for merge in merges:
                if merge != "META-INF":
                    extras.append("ln -sf lib-%s.so lib-%s.so" % (
                        pkg.replace(".", "-"), merge.replace(".", "-")))
        commands.extend(extras)
        return commands

    def __get_locator_build_commands(self):
        commands = []
        packages = copy.copy(self.packages)
        packages.sort()
        jarname = os.path.split(self.path)[1]
        end = "-%s.jar" % self.version
        if not jarname.endswith(end):
            jarname = jarname[:-4] + end
        if self.transform is None:
            transform = []
        else:
            transform = ["|", "sed", "'%s'" % self.transform]
        for pkg in packages:
            commands.append(" ".join(
                ["echo", jarname] + transform + [">", "lib-%s-%s.cp" % (
                pkg.replace(".", "-"), self.version)]))
        return commands

if __name__ == "__main__":
    import sys
    targets = JarList()
    targets.addFromCommandLine(sys.argv[1:])
    for command in targets.getBuildCommands():
        print command