/*
* #%L
* Wisdom-Framework
* %%
* Copyright (C) 2013 - 2014 Wisdom Framework
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.wisdom.maven.osgi;
import aQute.bnd.osgi.*;
import aQute.libg.reporter.ReporterAdapter;
import com.google.common.base.Joiner;
import org.apache.commons.io.IOUtils;
import org.apache.felix.ipojo.manipulator.Pojoization;
import org.apache.felix.ipojo.manipulator.util.Classpath;
import org.wisdom.bnd.plugins.ImportedPackageRangeFixer;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.*;
/**
* Packages the bundle using BND.
*/
public final class BundlePackager implements org.wisdom.maven.Constants {
private BundlePackager() {
//Hide default constructor
}
/**
* Creates the bundle.
*
* @param basedir the project's base directory
* @param output the output file
* @throws IOException occurs when the bundle cannot be built correctly.
*/
public static void bundle(File basedir, File output, Reporter reporter) throws IOException {
ProjectScanner scanner = new ProjectScanner(basedir);
// Loads the properties inherited from Maven.
Properties instructions = readMavenProperties(basedir);
// Loads the properties from the BND file.
Properties fromBnd = readInstructionsFromBndFile(basedir);
if (fromBnd == null) {
// No bnd files, use default instructions
instructions = populatePropertiesWithDefaults(basedir, instructions, scanner);
} else {
// We have a BND file.
// Do we have to merge ?
String noDefaultValue = fromBnd.getProperty("-no-default");
if (!"true".equalsIgnoreCase(noDefaultValue)) {
// So we need to merge the default with the bnd files
// 1) merge the instructions from the bnd files with the default
// 2) merge the resulting set of instruction onto the maven properties
// (and override the default)
instructions = Instructions.mergeAndOverrideExisting(
instructions,
populatePropertiesWithDefaults(basedir, fromBnd, scanner));
} else {
instructions = Instructions.mergeAndOverrideExisting(instructions, fromBnd);
}
}
// Manage Embedded dependencies
DependencyEmbedder ed = new DependencyEmbedder(instructions, reporter);
instructions = ed.generate(instructions, org.wisdom.maven.osgi.Classpath.load(basedir));
// Integrate custom headers added by other plugins.
instructions = mergeExtraHeaders(basedir, instructions);
// For debugging purpose, dump the instructions to target/osgi/instructions.properties
FileOutputStream fos = null;
try {
File out = new File(basedir, "target/osgi/instructions.properties");
fos = new FileOutputStream(out);
instructions.store(fos, "Wisdom BND Instructions");
} catch (IOException e) { // NOSONAR
// Ignore it.
} finally {
IOUtils.closeQuietly(fos);
}
// Instructions loaded, start the build sequence.
final Jar[] jars = org.wisdom.maven.osgi.Classpath.computeClassPath(basedir);
File bnd;
File ipojo;
Builder builder = null;
try {
builder = getOSGiBuilder(basedir, instructions, jars);
// The next sequence is weird
// First build the bundle with the given instruction
// Then analyze to apply the plugin and fix
// finally, rebuild with the updated metadata
// Without the first build, embedded dependencies and private packages from classpath are not analyzed.
builder.build();
builder.analyze();
builder.build();
reportErrors(builder.getWarnings(), builder.getErrors(), reporter);
bnd = File.createTempFile("bnd-", ".jar");
ipojo = File.createTempFile("ipojo-", ".jar");
builder.getJar().write(bnd);
} catch (Exception e) {
throw new IOException("Cannot build the OSGi bundle", e);
} finally {
if (builder != null) {
builder.close();
}
}
final Set<String> elements = org.wisdom.maven.osgi.Classpath.computeClassPathElement(basedir);
Classpath classpath = new Classpath(elements);
Pojoization pojoization = new Pojoization();
pojoization.pojoization(bnd, ipojo, new File(basedir, "src/main/resources"),
classpath.createClassLoader());
reportErrors(pojoization.getWarnings(), pojoization.getErrors(), reporter);
Files.move(Paths.get(ipojo.getPath()), Paths.get(output.getPath()),
StandardCopyOption.REPLACE_EXISTING);
}
/**
* If a bundle has added extra headers, they are added to the bundle manifest.
*
* @param baseDir the project directory
* @param properties the current set of properties in which the read metadata are written
* @return the merged set of properties
*/
private static Properties mergeExtraHeaders(File baseDir, Properties properties) throws IOException {
File extra = new File(baseDir, EXTRA_HEADERS_FILE);
return Instructions.merge(properties, extra);
}
/**
* This method is used by plugin willing to add custom header to the bundle manifest.
*
* @param baseDir the project directory
* @param header the header to add
* @param value the value to write
* @throws IOException if the header cannot be added
*/
public static void addExtraHeaderToBundleManifest(File baseDir, String header, String value) throws IOException {
Properties props = new Properties();
File extra = new File(baseDir, EXTRA_HEADERS_FILE);
extra.getParentFile().mkdirs();
// If the file exist it loads it, if not nothing happens.
props = Instructions.merge(props, extra);
if (value != null) {
props.setProperty(header, value);
} else {
props.remove(header);
}
FileOutputStream fos = null;
try {
fos = new FileOutputStream(extra);
props.store(fos, "");
} finally {
IOUtils.closeQuietly(fos);
}
}
/**
* We should have generated a {@code target/osgi/osgi.properties} file with the metadata we inherit from Maven.
*
* @param baseDir the project directory
* @return the computed set of properties
*/
public static Properties readMavenProperties(File baseDir) throws IOException {
return Instructions.load(new File(baseDir, org.wisdom.maven.Constants.OSGI_PROPERTIES));
}
/**
* Populates the given properties object with our BND default instructions (computed for the current project).
* Entries are not added if the given properties file already contains these values.
*
* @param basedir the project's base directory
* @param instructions the current set of properties in which the read metadata are written
* @param scanner the project scanner to retrieve information about the sources and resources contained in the
* project
* @return the final set of instructions (containing the default instructions merged into the
* given set of properties)
* @throws IOException if something wrong happens
*/
protected static Properties populatePropertiesWithDefaults(File basedir, Properties instructions,
ProjectScanner scanner) throws IOException {
Properties defaultInstructions = new Properties();
List<String> privates = new ArrayList<>();
List<String> exports = new ArrayList<>();
// Do local resources
String resources = getLocalResources(basedir, false, scanner);
if (!resources.isEmpty()) {
defaultInstructions.put(Analyzer.INCLUDE_RESOURCE, resources);
}
defaultInstructions.put(Constants.IMPORT_PACKAGE, "*");
for (String s : scanner.getPackagesFromMainSources()) {
if (Packages.shouldBeExported(s)) {
exports.add(s);
} else {
if (!s.isEmpty() && !s.equals(".")) {
privates.add(s + ";-split-package:=merge-first");
}
}
}
defaultInstructions.put(Constants.PRIVATE_PACKAGE, Packages.toClause(privates));
defaultInstructions.put(Constants.EXPORT_PACKAGE, Packages.toClause(exports));
return Instructions.mergeAndSkipExisting(instructions, defaultInstructions);
}
/**
* Gets local resources.
*
* @param basedir the project's base directory
* @param test whether or not we compute the test resources
* @param scanner the project scanner to retrieve information about the sources and resources contained in the
* project
* @return the resource clause
*/
public static String getLocalResources(File basedir, boolean test, ProjectScanner scanner) {
final String basePath = basedir.getAbsolutePath();
String target = "target/classes";
if (test) {
target = "target/test-classes";
}
Set<String> files = scanner.getLocalResources(test);
Set<String> pathSet = new LinkedHashSet<>();
for (String name : files) {
String path = target + '/' + name;
// make relative to project
if (path.startsWith(basePath)) {
if (path.length() == basePath.length()) {
path = ".";
} else {
path = path.substring(basePath.length() + 1);
}
}
// replace windows backslash with a slash
// this is a workaround for a problem with bnd 0.0.189
if (File.separatorChar != '/') {
name = name.replace(File.separatorChar, '/');
path = path.replace(File.separatorChar, '/');
}
// copy to correct place
path = name + '=' + path;
pathSet.add(path);
}
return Joiner.on(", ").join(pathSet);
}
private static Builder getOSGiBuilder(File basedir, Properties properties,
Jar[] classpath) {
Builder builder = new Builder();
synchronized (BundlePackager.class) {
builder.setBase(basedir);
}
// Add the range fixer plugin
final ImportedPackageRangeFixer plugin = new ImportedPackageRangeFixer();
plugin.setReporter(builder);
plugin.setProperties(Collections.<String, String>emptyMap());
builder.addBasicPlugin(plugin);
builder.setProperties(Instructions.sanitize(properties));
if (classpath != null) {
builder.setClasspath(classpath);
}
return builder;
}
private static Properties readInstructionsFromBndFile(File basedir) throws IOException {
File instructionFile = new File(basedir, INSTRUCTIONS_FILE);
if (!instructionFile.isFile()) {
return null;
}
return Instructions.load(instructionFile);
}
private static boolean reportErrors(List<String> warnings, List<String> errors, Reporter reporter) {
for (String msg : warnings) {
reporter.warn(msg);
}
boolean hasErrors = false;
String fileNotFound = "Input file does not exist: ";
for (String msg : errors) {
if (msg.startsWith(fileNotFound) && msg.endsWith("~")) {
// treat as warning; this error happens when you have duplicate entries in Include-Resource
String duplicate = Processor.removeDuplicateMarker(msg.substring(fileNotFound.length()));
reporter.warn("Duplicate path '" + duplicate + "' in Include-Resource");
} else {
reporter.error(msg);
hasErrors = true;
}
}
return hasErrors;
}
}