# ###############################################################################
# Copyright (c) 2014 CEA LIST.
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
#
# Contributors:
# Laurent Wouters laurent.wouters@cea.fr - Initial API and implementation
#
# ###############################################################################
"""
This script provides an API to generate the Tycho
configuration files (pom.xml) for an Eclipse code repository
"""
import os # File handling
import os.path # File path handling
import sys # System
import xml.dom.minidom # Minimal XML
import console # Console pretty printing
import eclipse # Eclipse API
import xmlutils # XML utilities
class Target:
"""
Represents a build target
"""
def __init__(self, name, pom, site, feature):
"""
Initializes this build target
:param name: The target's name
:param pom: Path to the target top pom.xml
:param site: Path to the target's site
:param feature: Identifier of the target's top Eclipse feature
:return: The build target
"""
self.name = name
self.pom = pom
self.site = site
self.feature = feature
# General constants
MAVEN_MODEL_VERSION = "4.0.0"
# Product constants
PRODUCT_VERSION = "1.0.0"
PRODUCT_CATEGORY_ID = "org.eclipse.papyrus.category"
PRODUCT_CATEGORY_LABEL = "Papyrus Category"
PRODUCT_CATEGORY_DESC = PRODUCT_CATEGORY_LABEL
PRODUCT_GROUP = "org.eclipse.papyrus"
# Generator targets configuration
TARGETS = [Target("main",
"releng/top-pom-main.xml",
"releng/main",
"org.eclipse.papyrus.sdk.feature"),
Target("extras",
"releng/top-pom-extras.xml",
"releng/extras",
"org.eclipse.papyrus.extra.feature"),
Target("dev",
"releng/top-pom-dev.xml",
"releng/dev",
"org.eclipse.papyrus.dev.feature")]
# Generator inputs configuration
INPUTS = [
"plugins",
"extraplugins",
"features/papyrus-main-features",
"features/papyrus-extra-features",
"features/papyrus-dev-features"
]
# Pattern to recognize required plugin to include in the build
PATTERN_INCLUDE = "org\\.eclipse\\.papyrus\\..*"
# Pattern to recognize required plugin to exclude from the build
PATTERN_EXCLUDE = "(.*\\.source.feature)|(.*\\.tests)"
def print_usage():
"""
Print how to use this script
:return: None
"""
print("Usage:")
print(" python tycho-generator.py [-h | --help] [--color]")
print("Options:")
print(" -h, --help: print this screen")
print(" --color: activate console color")
def generate(inputs, targets, include_pattern, exclude_pattern):
"""
Generate the Tycho data and files
:param inputs: Array of input directories to load Eclipse plugins and features from
:param targets: Array of build targets
:param include_pattern: Pattern matching Eclipse bundle to include into a build target
:param exclude_pattern: Pattern matching Eclipse bundle to exclude from any build target
:return: The error code, or 0 if all went well
"""
# Build repo
console.log("== Preparing the repository ...")
repo = __build_repository(inputs, include_pattern, exclude_pattern)
if repo is None:
return 1
# Setup the bundles' target data
for target in targets:
__add_target(repo, target.feature, target)
# Generate all bundles POM
console.log("== Generating POM for features ...")
for name in iter(sorted(repo.features)):
if not __generate_bundle_pom(repo.features[name], "eclipse-feature"):
return 2
console.log("== Generating POM for plugins ...")
for name in iter(sorted(repo.plugins)):
if not __generate_bundle_pom(repo.plugins[name], "eclipse-plugin"):
return 2
# Update the targets' top pom.xml
console.log("== Updating the module references in top POMs ...")
for target in targets:
__update_modules(repo, target)
return 0
def __build_repository(inputs, include_pattern, exclude_pattern):
"""
Gets an initialized repository of features and plugins
:param inputs: Array of input directories to load Eclipse plugins and features from
:param include_pattern: Pattern matching Eclipse bundle to include into a build target
:param exclude_pattern: Pattern matching Eclipse bundle to exclude from any build target
:return: The corresponding repository of Eclipse plugins and features
"""
# Build the repo
repository = eclipse.Repository()
for directory_input in inputs:
repository.load(directory_input)
# Check for missing bundles
missing = repository.check(include_pattern, exclude_pattern)
for m in missing:
console.log("Missing bundle " + m, "ERROR")
if len(missing) > 0:
return None
# Initializes the targets
for name in repository.plugins:
repository.plugins[name].targets = []
for name in repository.features:
repository.features[name].targets = []
return repository
def __add_target(repository, feature_identifier, target):
"""
Recursively add a build target to a feature, its included features and its plugins
:param repository: The Eclipse repository to work on
:param feature_identifier: The identifier of the Eclipse feature to add a build target for
:param target: The build target to add
:return: None
"""
# If the feature is missing
if not feature_identifier in repository.features:
return
feature = repository.features[feature_identifier]
# Add the target is required
if not target in feature.targets:
feature.targets.append(target)
# Traverse all sub-features
for included in feature.included:
__add_target(repository, included, target)
# Traverse all plugins
for name in feature.plugins:
if name in repository.plugins:
plugin = repository.plugins[name]
if not target in plugin.targets:
plugin.targets.append(target)
def __generate_bundle_pom(bundle, packaging):
"""
Generate the pom.xml file for the given bundle and given packaging
:param bundle: The bundle to generate the pom for
:param packaging: The type of packaging (feature or plugin)
:return: True if the operation succeeded, False otherwise
"""
if len(bundle.targets) == 0:
console.log("Bundle " + bundle.name + " has no target => skipped", "WARNING")
return True
if len(bundle.targets) >= 2:
console.log("Bundle " + bundle.name + " has more than one target:", "ERROR")
for target in bundle.targets:
console.log("\t" + target, "ERROR")
return False
if os.path.isfile(os.path.join(bundle.location, "pom.xml")):
console.log("Bundle " + bundle.name + " already has pom.xml => skipped")
return True
relative = os.path.relpath(".", bundle.location)
relative = os.path.join(relative, bundle.targets[0].pom)
impl = xml.dom.minidom.getDOMImplementation()
doc = impl.createDocument(None, "project", None)
project = doc.documentElement
__xml_append_text(doc, project, "modelVersion", MAVEN_MODEL_VERSION)
parent = doc.createElement("parent")
project.appendChild(parent)
__xml_append_tycho_ref(doc, parent, PRODUCT_GROUP)
__xml_append_text(doc, parent, "relativePath", relative)
__xml_append_tycho_ref(doc, project, bundle.name)
__xml_append_text(doc, project, "packaging", packaging)
xmlutils.output(doc, os.path.join(bundle.location, "pom.xml"))
console.log("Bundle " + bundle.name + " POM generated for target " + bundle.targets[0].name)
return True
def __xml_append_text(doc, parent, tag, content):
"""
Append an element node with the given tag and content
:param doc: The parent document
:param parent: The parent XML element node
:param tag: The element tag to create
:param content: The content of the element to create
:return: None
"""
child = doc.createElement(tag)
parent.appendChild(child)
child.appendChild(doc.createTextNode(content))
def __xml_append_tycho_ref(doc, parent, tycho_identifier):
"""
Append a reference to a Tycho module
:param doc: The parent document
:param parent: The parent XML element node
:param tycho_identifier: The Tycho module identifier
:return:
"""
__xml_append_text(doc, parent, "artifactId", tycho_identifier)
__xml_append_text(doc, parent, "groupId", PRODUCT_GROUP)
__xml_append_text(doc, parent, "version", PRODUCT_VERSION + "-SNAPSHOT")
def __update_modules(repository, target):
"""
Updates the modules for the given target
:param repository: The Eclipse repository to work on
:param target: The build target to update
:return: None
"""
doc = xml.dom.minidom.parse(target.pom)
modules = doc.getElementsByTagName("modules")[0]
for module in modules.getElementsByTagName("module"):
modules.removeChild(module)
for name in iter(sorted(repository.features)):
feature = repository.features[name]
if target in feature.targets:
modules.appendChild(__get_module_node(feature, doc))
for name in iter(sorted(repository.plugins)):
plugin = repository.plugins[name]
if target in plugin.targets:
modules.appendChild(__get_module_node(plugin, doc))
repo_node = doc.createElement("module")
repo_node.appendChild(doc.createTextNode(target.name))
modules.appendChild(repo_node)
xmlutils.output(doc, target.pom)
console.log("Updated top POM for target " + target.name)
def __get_module_node(bundle, doc):
"""
Get the path to the specified bundle relatively to the given target's top POM
:param bundle: An Eclipse bundle
:param doc: The parent XML document
:return: The XML node containing the relative path
"""
child = doc.createElement("module")
child.appendChild(doc.createTextNode(os.path.join("..", bundle.location)))
return child
# Main script
if __name__ == "__main__":
# Checks the arguments
for arg in sys.argv[1:]:
if arg == "-h" or arg == "--help":
print_usage()
sys.exit(0)
elif arg == console.CLI_COLOR:
console.USE_COLOR = True
# Execute the generation
code = generate(INPUTS, TARGETS, PATTERN_INCLUDE, PATTERN_EXCLUDE)
sys.exit(code)
