Current File : //usr/share/java-utils/maven_depmap.py
#!/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)
Mini Shell