1#@!#!123s

: / usr / share / java-utils /
Filename : maven_depmap.py
back
#!/usr/bin/python
# Copyright (c) 2012-2013, Red Hat, Inc
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the
#    distribution.
# 3. Neither the name of Red Hat nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors: Stanislav Ochotnicky <sochotnicky@redhat.com>
#
# this script is used by add_maven_depmap rpm macro to generate
# mapping between maven groupId:artifactId and jar file in our local
# filesystem (i.e. %{_javadir})
# rpm macro expects to find this file as %{_javadir}-utils/maven_depmap.py

from optparse import OptionParser
import sys
import os
import re
import shutil
from StringIO import StringIO
import xml.dom.minidom
import codecs

from os.path import basename, dirname
import zipfile
from time import gmtime, strftime

from lxml.etree import SubElement, Element, ElementTree, XMLParser

from javapackages import POM, Artifact


class Fragment:
    """simple structure to hold fragment information"""
    def __init__(self, upstream_artifact, local_artifact):
        self.upstream_artifact = upstream_artifact
        self.local_artifact = local_artifact

    def __getitem__(self, index):
        return self.__dict__[index]


class PackagingTypeMissingFile(Exception):
    def __init__(self, pom_path):
        self.args=("Packaging type is not 'pom' and no artifact path has been provided for POM %s" % pom_path,)

class IncompatibleFilenames(Exception):
    def __init__(self, pom_path, jar_path):
        self.args=("Filenames of POM %s and JAR %s does not match properly. Check that JAR subdirectories matches '.' in pom name." % (pom_path, jar_path),)

class MissingJarFile(Exception):
    def __init__(self):
        self.args=("JAR seems to be missing in standard directories. Make sure you have installed it",)

class UnknownFileExtension(Exception):
    def __init__(self, jar_path):
        self.args=("Unknown file extension: %s" % (jar_path),)

def _get_javadir_part(jar_path, prefix):
    # This is not nice, because macros can change but handling these
    # in RPM macros is ugly as hell.
    javadirs=[os.path.join(prefix, part) for part in ["share/java",
                                                      "share/java-jni",
                                                      "lib/java",
                                                      "lib64/java"]]
    jarpart = None
    for jdir in javadirs:
        if jdir in jar_path:
            javadir_re = re.compile(".*%s/" % jdir)
            jarpart = re.sub(javadir_re, "", jar_path)
    if not jarpart:
        raise MissingJarFile()
    return jarpart

def _get_jpp_from_filename(pom_path, prefix, jar_path = None, extension = "jar"):
    """Get resolved (groupId,artifactId) tuple from POM and JAR path.

    POM name and JAR name have to be compatible.
    JPP.xbean-xbean-main.pom means groupId is "JPP/xbean" and artifactId
    is "xbean-main". Therefore for JAR name to be compatible it has be
    in %{_javadir}/xbean/xbean-main.jar.
    """
    pomname = basename(pom_path)
    if jar_path:
        if not os.path.isfile(jar_path):
            raise IOError("JAR path doesn't exist")
        jarpart = _get_javadir_part(jar_path, prefix)

        if pomname[3] == '.':
            if '/' not in jarpart:
                raise IncompatibleFilenames(pom_path, jar_path)
            jpp_gid = "JPP/%s" % dirname(jarpart)
            jpp_aid = basename(jarpart[:-(len(extension)+1)])
            # we assert that jar and pom parts match
            if not pomname == "JPP.%s-%s.pom" % (jpp_gid[4:], jpp_aid):
                raise IncompatibleFilenames(pom_path, jar_path)
        else:
            if '/' in jarpart:
                raise IncompatibleFilenames(pom_path, jar_path)
            jpp_gid = "JPP"
            jpp_aid = basename(jarpart[:-(len(extension)+1)])
            # we assert that jar and pom parts match
            if not pomname == "JPP-%s.pom" % jpp_aid:
                raise IncompatibleFilenames(pom_path, jar_path)
    else:
        if pomname[3] == ".":
            match = re.match('JPP\.([^-]*?)-.*', pomname)
            jpp_gid="JPP/%s" % match.group(1)
            match = re.match('JPP\.[^-]*?-(.*)\.pom', pomname)
            jpp_aid= match.group(1)
        else:
            jpp_gid = "JPP"
            jpp_aid = pomname[4:-4]
    return(jpp_gid, jpp_aid)

def _make_files_versioned(versions, pom_path, jar_path):
    """Make pom and jar file versioned"""
    versions = list(set(versions.split(',')))

    vpom_path = pom_path
    vjar_path = jar_path

    # pom
    if ':' not in vpom_path:
        root, ext = os.path.splitext(vpom_path)
        symlink = False
        for ver in sorted(versions):
            dest = "%s-%s%s" % (root, ver, ext)
            if not symlink:
                shutil.copy(os.path.realpath(vpom_path), dest)
                symlink = True
                vpom_path = dest
            else:
                os.symlink(basename(vpom_path), dest)
            # output file path for file lists
            print dest
        # remove unversioned pom
        os.remove(pom_path)

    # jar
    if vjar_path:
        root, ext = os.path.splitext(vjar_path)
        symlink = False
        for ver in sorted(versions):
            dest = "%s-%s%s" % (root, ver, ext)
            if not symlink:
                shutil.copy(os.path.realpath(vjar_path), dest)
                symlink = True
                vjar_path = dest
            else:
                os.symlink(basename(vjar_path), dest)
            # output file path for file lists
            print dest
        # remove unversioned jar
        os.remove(jar_path)

def get_local_artifact(upstream_artifact, prefix, jar_path=None):
    if not jar_path:
        # does this even make sense? There is no pom, no dependencies...
        return Artifact("JPP", upstream_artifact.artifactId,
                        upstream_artifact.extension,
                        upstream_artifact.classifier,
                        upstream_artifact.version)

    jarpart = _get_javadir_part(jar_path, prefix)
    local_gid = "JPP"
    if '/' in jarpart:
        local_gid = "JPP/{gid}".format(gid=dirname(jarpart))

    ext = upstream_artifact.extension
    if not ext:
        ext = "jar"

    if not jarpart.endswith(".{ext}".format(ext=ext)):
        raise IncompatibleFilenames(str(upstream_artifact), jar_path)

    fname = basename(jarpart).replace(".{ext}".format(ext=ext),
                                      "")

    local_aid = fname
    if upstream_artifact.classifier:
        local_aid = fname[:fname.rfind('-')]
        if fname[fname.rfind('-')+1:] != upstream_artifact.classifier:
            raise IncompatibleFilenames(str(upstream_artifact), jar_path)
    return Artifact(local_gid, local_aid, upstream_artifact.extension,
                    upstream_artifact.classifier, upstream_artifact.version)


def parse_pom(pom_file, prefix, jar_file = None):
    """Returns Fragment class or None if POM file is invalid"""
    pom = POM(pom_file)

    extension = ''
    # if project packaging is undefined => jar
    # only "pom" packaging type can be without jar_file path otherwise
    # we bail
    if not jar_file:
        if not pom.packaging or pom.packaging != "pom":
            raise PackagingTypeMissingFile(pom_path)
        extension = 'pom'
    else:
        # let's just take last part of filename as extension
        fname, ext = os.path.splitext(jar_path)
        extension = ext[1:]

    jpp_gid, jpp_aid = _get_jpp_from_filename(pom_file, prefix, jar_file, extension)

    if extension == "jar":
        extension = ''

    upstream_artifact = Artifact(pom.groupId, pom.artifactId, extension=extension, version=pom.version)
    local_artifact = Artifact(jpp_gid, jpp_aid, extension)
    return Fragment(upstream_artifact, local_artifact)

def create_mappings(fragment, additions=None, namespace=""):
    fragment.upstream_artifact.namespace = namespace
    fragment.local_artifact.namespace = namespace
    maps = [fragment]
    if additions:
        adds = additions.split(',')
        for add in adds:
            mpart = Artifact.from_mvn_str(add)
            full = Artifact.merge_artifacts(mpart, fragment.upstream_artifact)
            maps.append(Fragment(full, fragment.local_artifact))
    return maps

def prettify_element(elem):
    xmlbuf = StringIO()
    et = ElementTree()
    et._setroot(elem)
    et.write(xmlbuf,
             xml_declaration=True,
             encoding = 'utf-8',
             method = "xml")
    return xml.dom.minidom.parseString(xmlbuf.getvalue()).toprettyxml()

def output_fragment(fragment_path, fragment, mappings, add_versions):
    """Writes fragment into fragment_path in specialised format
    compatible with jpp"""
    root = None
    try:
        et = ElementTree()
        parser = XMLParser(remove_blank_text=True)
        root = et.parse(fragment_path, parser=parser)
    except IOError:
        root = Element("dependencyMap")

    if not add_versions:
        versions = set()
    else:
        versions = set(add_versions.split(','))

    if add_versions or add_versions == "":
        # skip RPM provides in compat packages
        SubElement(root, "skipProvides")

    versions.add(fragment.upstream_artifact.version)
    versions = list(versions)
    for ver in sorted(versions):
        for fragment in mappings:
            dep = SubElement(root, "dependency")
            if add_versions or add_versions == "":
                fragment.local_artifact.version = ver
            else:
                fragment.local_artifact.version = ""
            mvn_xml = fragment.upstream_artifact.get_xml_element(root="maven")
            local_xml = fragment.local_artifact.get_xml_element(root="jpp")

            dep.append(mvn_xml)
            dep.append(local_xml)
    xmlstr = prettify_element(root)
    with codecs.open(fragment_path, 'w', "utf-8") as fout:
        fout.write(xmlstr)



# Add a file to a ZIP archive (or JAR, WAR, ...) unless the file
# already exists in the archive.  Provided by Tomas Radej.
def append_if_missing(archive_name, file_name, file_contents):
    archive = zipfile.ZipFile(archive_name, 'a')
    try:
        if file_name not in archive.namelist():
            path = os.path.dirname(file_name)
            while True:
                if not path:
                    break
                subdir = path + os.path.sep
                if subdir not in archive.namelist():
                    archive.writestr(subdir, '')
                path, tail = os.path.split(path)
            archive.writestr(file_name, file_contents)
    finally:
        archive.close()

# Inject pom.properties if JAR doesn't have one.  This is necessary to
# identify the origin of JAR files that are present in the repository.
def inject_pom_properties(jar_path, fragment):
    props_path = "META-INF/maven/{f.groupId}/{f.artifactId}/pom.properties".format(f=fragment.upstream_artifact)
    timestamp = strftime("%a %b %d %H:%M:%S UTC %Y", gmtime())
    properties = """#Generated by Java Packages Tools
#{timestamp}
version={f.upstream_artifact.version}
groupId={f.upstream_artifact.groupId}
artifactId={f.upstream_artifact.artifactId}
""".format(timestamp=timestamp,
           f=fragment)

    artifact = fragment.upstream_artifact
    if artifact.extension:
        properties = properties + \
            "extension={ext}\n".format(ext=artifact.extension)
    if artifact.classifier:
        properties = properties + \
            "classifier={clas}\n".format(clas=artifact.classifier)

    append_if_missing(jar_path, props_path, properties)

if __name__ == "__main__":

    usage="usage: %prog [options] fragment_path pom_path|<MVN spec> [jar_path]"
    parser = OptionParser(usage=usage)
    parser.add_option("-a","--append",type="str",
                      help="Additional depmaps to add (gid:aid)  [default: %default]")
    parser.add_option('-r', '--versions', type="str",
                      help='Additional versions to add for each depmap')
    parser.add_option('-n', '--namespace', type="str",
                      help='Namespace to use for generated fragments', default="")
    parser.add_option('-p', '--prefix', type="str",
                      help='Prefix where artifacts are expected to be installed', default="/")



    parser.set_defaults(append=None)

    (options, args) = parser.parse_args()
    append_deps = options.append
    add_versions = options.versions
    namespace = options.namespace
    prefix = options.prefix

    if len(args) < 2:
        parser.error("Incorrect number of arguments")
    # These will fail when incorrect number of arguments is given.
    fragment_path = args[0].strip()
    pom_path = args[1].strip()
    jar_path = None

    if len(args) == 3:
        jar_path = args[2].strip()
        local = None
        fragment = None
        if ':' in pom_path:
            pom_str = pom_path.rsplit('/')[-1]
            upstream = Artifact.from_mvn_str(pom_str)
            if upstream.extension == 'jar':
                upstream.extension = ''
            if not upstream.version:
                parser.error("Artifact definition has to include version")
            local = get_local_artifact(upstream, prefix, jar_path)
            fragment = Fragment(upstream, local)
        else:
            fragment = parse_pom(pom_path, prefix, jar_path)
        if fragment:
            inject_pom_properties(jar_path, fragment)
    else:
        fragment = parse_pom(pom_path, prefix)

    # output file path for file lists
    print fragment_path

    if fragment:
        mappings = create_mappings(fragment, append_deps, namespace)
        output_fragment(fragment_path, fragment, mappings, add_versions)

        if add_versions:
            add_versions = "%s,%s" % (fragment.upstream_artifact.version, add_versions)
            _make_files_versioned(add_versions, pom_path, jar_path)
        else:
            # output file paths for file lists
            if ':' not in pom_path:
                print pom_path
            if jar_path:
                print jar_path

    else:
        parser.error("Problem parsing POM file. Is it valid maven POM? Send bugreport \
        to https://fedorahosted.org/javapackages/ and attach %s to \
        this bugreport" % pom_path)
        sys.exit(1)