org.apache.felix.bundleplugin.BundlePlugin Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of maven-bundle-plugin Show documentation
Show all versions of maven-bundle-plugin Show documentation
Provides a maven plugin that supports creating an OSGi bundle
from the contents of the compilation classpath along with its
resources and dependencies. Plus a zillion other features.
The plugin uses the Bnd tool (http://www.aqute.biz/Code/Bnd)
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.felix.bundleplugin;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import org.apache.maven.archiver.ManifestSection;
import org.apache.maven.archiver.MavenArchiveConfiguration;
import org.apache.maven.archiver.MavenArchiver;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.License;
import org.apache.maven.model.Model;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.plugins.annotations.Component;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectHelper;
import org.apache.maven.shared.dependency.graph.DependencyGraphBuilder;
import org.apache.maven.shared.dependency.graph.DependencyGraphBuilderException;
import org.apache.maven.shared.dependency.graph.DependencyNode;
import org.apache.maven.shared.osgi.DefaultMaven2OsgiConverter;
import org.apache.maven.shared.osgi.Maven2OsgiConverter;
import org.codehaus.plexus.archiver.UnArchiver;
import org.codehaus.plexus.archiver.manager.ArchiverManager;
import org.codehaus.plexus.util.DirectoryScanner;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.PropertyUtils;
import org.codehaus.plexus.util.StringUtils;
import aQute.bnd.header.Attrs;
import aQute.bnd.header.OSGiHeader;
import aQute.bnd.header.Parameters;
import aQute.bnd.osgi.Analyzer;
import aQute.bnd.osgi.Builder;
import aQute.bnd.osgi.Constants;
import aQute.bnd.osgi.Descriptors.PackageRef;
import aQute.bnd.osgi.EmbeddedResource;
import aQute.bnd.osgi.FileResource;
import aQute.bnd.osgi.Instruction;
import aQute.bnd.osgi.Instructions;
import aQute.bnd.osgi.Jar;
import aQute.bnd.osgi.Packages;
import aQute.bnd.osgi.Processor;
import aQute.lib.collections.ExtList;
import aQute.lib.spring.SpringXMLType;
import aQute.libg.generics.Create;
/**
* Create an OSGi bundle from Maven project
*
*/
@Mojo( name = "bundle", requiresDependencyResolution = ResolutionScope.TEST,
threadSafe = true,
defaultPhase = LifecyclePhase.PACKAGE )
public class BundlePlugin extends AbstractMojo
{
/**
* Directory where the manifest will be written
*/
@Parameter( property = "manifestLocation", defaultValue = "${project.build.outputDirectory}/META-INF" )
protected File manifestLocation;
/**
* Output a nicely formatted manifest that still respects the 72 character line limit.
*/
@Parameter( property = "niceManifest", defaultValue = "false" )
protected boolean niceManifest;
/**
* File where the BND instructions will be dumped
*/
@Parameter( property = "dumpInstructions" )
protected File dumpInstructions;
/**
* File where the BND class-path will be dumped
*/
@Parameter( property = "dumpClasspath" )
protected File dumpClasspath;
/**
* When true, unpack the bundle contents to the outputDirectory
*/
@Parameter( property = "unpackBundle" )
protected boolean unpackBundle;
/**
* Comma separated list of artifactIds to exclude from the dependency classpath passed to BND (use "true" to exclude everything)
*/
@Parameter( property = "excludeDependencies" )
protected String excludeDependencies;
/**
* Final name of the bundle (without classifier or extension)
*/
@Parameter( defaultValue = "${project.build.finalName}")
private String finalName;
/**
* Classifier type of the bundle to be installed. For example, "jdk14".
* Defaults to none which means this is the project's main bundle.
*/
@Parameter
protected String classifier;
/**
* Packaging type of the bundle to be installed. For example, "jar".
* Defaults to none which means use the same packaging as the project.
*/
@Parameter
protected String packaging;
@Component
private MavenProjectHelper m_projectHelper;
@Component
private ArchiverManager m_archiverManager;
@Component
private ArtifactHandlerManager m_artifactHandlerManager;
@Component
private DependencyGraphBuilder m_dependencyGraphBuilder;
/**
* Project types which this plugin supports.
*/
@Parameter
protected List supportedProjectTypes = Arrays.asList( new String[]
{ "jar", "bundle" } );
/**
* The directory for the generated bundles.
*/
@Parameter( defaultValue = "${project.build.outputDirectory}" )
private File outputDirectory;
/**
* The directory for the generated JAR.
*/
@Parameter( defaultValue = "${project.build.directory}" )
private String buildDirectory;
/**
* The Maven project.
*/
@Parameter( defaultValue = "${project}", readonly = true, required = true )
private MavenProject project;
/**
* The BND instructions for the bundle.
*/
@Parameter
private Map instructions = new LinkedHashMap();
/**
* Use locally patched version for now.
*/
private final Maven2OsgiConverter m_maven2OsgiConverter = new DefaultMaven2OsgiConverter();
/**
* The archive configuration to use.
*/
@Parameter
private MavenArchiveConfiguration archive; // accessed indirectly in JarPluginConfiguration
@Parameter( defaultValue = "${session}", readonly = true, required = true )
private MavenSession m_mavenSession;
private static final String MAVEN_SYMBOLICNAME = "maven-symbolicname";
private static final String MAVEN_RESOURCES = "{maven-resources}";
private static final String MAVEN_TEST_RESOURCES = "{maven-test-resources}";
private static final String LOCAL_PACKAGES = "{local-packages}";
private static final String MAVEN_SOURCES = "{maven-sources}";
private static final String MAVEN_TEST_SOURCES = "{maven-test-sources}";
private static final String BUNDLE_PLUGIN_EXTENSION = "BNDExtension-";
private static final String BUNDLE_PLUGIN_PREPEND_EXTENSION = "BNDPrependExtension-";
private static final String[] EMPTY_STRING_ARRAY =
{};
private static final String[] DEFAULT_INCLUDES =
{ "**/**" };
private static final String NL = System.getProperty( "line.separator" );
protected Maven2OsgiConverter getMaven2OsgiConverter()
{
return m_maven2OsgiConverter;
}
protected MavenProject getProject()
{
return project;
}
protected DependencyNode buildDependencyGraph( MavenProject mavenProject ) throws MojoExecutionException
{
DependencyNode dependencyGraph;
try
{
dependencyGraph = m_dependencyGraphBuilder.buildDependencyGraph( mavenProject, null );
}
catch ( DependencyGraphBuilderException e )
{
throw new MojoExecutionException( e.getMessage(), e );
}
return dependencyGraph;
}
/**
* @see org.apache.maven.plugin.AbstractMojo#execute()
*/
public void execute() throws MojoExecutionException
{
Properties properties = new Properties();
String projectType = getProject().getArtifact().getType();
// ignore unsupported project types, useful when bundleplugin is configured in parent pom
if ( !supportedProjectTypes.contains( projectType ) )
{
getLog().warn(
"Ignoring project type " + projectType + " - supportedProjectTypes = " + supportedProjectTypes );
return;
}
execute( getProject(), buildDependencyGraph(getProject()), instructions, properties );
}
protected void execute( MavenProject currentProject, DependencyNode dependencyGraph, Map originalInstructions, Properties properties )
throws MojoExecutionException
{
try
{
execute( currentProject, dependencyGraph, originalInstructions, properties, getClasspath( currentProject, dependencyGraph ) );
}
catch ( IOException e )
{
throw new MojoExecutionException( "Error calculating classpath for project " + currentProject, e );
}
}
/* transform directives from their XML form to the expected BND syntax (eg. _include becomes -include) */
protected static Map transformDirectives( Map originalInstructions )
{
Map transformedInstructions = new LinkedHashMap();
for ( Iterator> i = originalInstructions.entrySet().iterator(); i.hasNext(); )
{
Map.Entry e = i.next();
String key = e.getKey();
if ( key.startsWith( "_" ) )
{
key = "-" + key.substring( 1 );
}
String value = e.getValue();
if ( null == value )
{
value = "";
}
else
{
value = value.replaceAll( "\\p{Blank}*[\r\n]\\p{Blank}*", "" );
}
if ( Analyzer.WAB.equals( key ) && value.length() == 0 )
{
// provide useful default
value = "src/main/webapp/";
}
transformedInstructions.put( key, value );
}
return transformedInstructions;
}
protected boolean reportErrors( String prefix, Analyzer analyzer )
{
List errors = analyzer.getErrors();
List warnings = analyzer.getWarnings();
for ( Iterator w = warnings.iterator(); w.hasNext(); )
{
String msg = w.next();
getLog().warn( prefix + " : " + msg );
}
boolean hasErrors = false;
String fileNotFound = "Input file does not exist: ";
for ( Iterator e = errors.iterator(); e.hasNext(); )
{
String msg = e.next();
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() ) );
getLog().warn( prefix + " : Duplicate path '" + duplicate + "' in Include-Resource" );
}
else
{
getLog().error( prefix + " : " + msg );
hasErrors = true;
}
}
return hasErrors;
}
protected void execute( MavenProject currentProject, DependencyNode dependencyGraph, Map originalInstructions, Properties properties,
Jar[] classpath ) throws MojoExecutionException
{
try
{
File jarFile = new File( getBuildDirectory(), getBundleName( currentProject ) );
Builder builder = buildOSGiBundle( currentProject, dependencyGraph, originalInstructions, properties, classpath );
boolean hasErrors = reportErrors( "Bundle " + currentProject.getArtifact(), builder );
if ( hasErrors )
{
String failok = builder.getProperty( "-failok" );
if ( null == failok || "false".equalsIgnoreCase( failok ) )
{
jarFile.delete();
throw new MojoFailureException( "Error(s) found in bundle configuration" );
}
}
// attach bundle to maven project
jarFile.getParentFile().mkdirs();
builder.getJar().write( jarFile );
Artifact mainArtifact = currentProject.getArtifact();
if ( "bundle".equals( mainArtifact.getType() ) )
{
// workaround for MNG-1682: force maven to install artifact using the "jar" handler
mainArtifact.setArtifactHandler( m_artifactHandlerManager.getArtifactHandler( "jar" ) );
}
boolean customClassifier = null != classifier && classifier.trim().length() > 0;
boolean customPackaging = null != packaging && packaging.trim().length() > 0;
if ( customClassifier && customPackaging )
{
m_projectHelper.attachArtifact( currentProject, packaging, classifier, jarFile );
}
else if ( customClassifier )
{
m_projectHelper.attachArtifact( currentProject, jarFile, classifier );
}
else if ( customPackaging )
{
m_projectHelper.attachArtifact( currentProject, packaging, jarFile );
}
else
{
mainArtifact.setFile( jarFile );
}
if ( unpackBundle )
{
unpackBundle( jarFile );
}
if ( manifestLocation != null )
{
File outputFile = new File( manifestLocation, "MANIFEST.MF" );
try
{
ManifestPlugin.writeManifest( builder, outputFile, niceManifest );
}
catch ( IOException e )
{
getLog().error( "Error trying to write Manifest to file " + outputFile, e );
}
}
// cleanup...
builder.close();
}
catch ( MojoFailureException e )
{
getLog().error( e.getLocalizedMessage() );
throw new MojoExecutionException( "Error(s) found in bundle configuration", e );
}
catch ( Exception e )
{
getLog().error( "An internal error occurred", e );
throw new MojoExecutionException( "Internal error in maven-bundle-plugin", e );
}
}
protected Builder getOSGiBuilder( MavenProject currentProject, Map originalInstructions, Properties properties,
Jar[] classpath ) throws Exception
{
properties.putAll( getDefaultProperties( currentProject ) );
properties.putAll( transformDirectives( originalInstructions ) );
// process overrides from project
final Map addProps = new HashMap();
final Iterator> iter = currentProject.getProperties().entrySet().iterator();
while ( iter.hasNext() )
{
final Map.Entry entry = iter.next();
final String key = entry.getKey().toString();
if ( key.startsWith(BUNDLE_PLUGIN_EXTENSION) )
{
final String oKey = key.substring(BUNDLE_PLUGIN_EXTENSION.length());
final String currentValue = properties.getProperty(oKey);
if ( currentValue == null )
{
addProps.put(oKey, entry.getValue().toString());
}
else
{
addProps.put(oKey, currentValue + ',' + entry.getValue());
}
}
if ( key.startsWith(BUNDLE_PLUGIN_PREPEND_EXTENSION) )
{
final String oKey = key.substring(BUNDLE_PLUGIN_PREPEND_EXTENSION.length());
final String currentValue = properties.getProperty(oKey);
if ( currentValue == null )
{
addProps.put(oKey, entry.getValue().toString());
}
else
{
addProps.put(oKey, entry.getValue() + "," + currentValue);
}
}
}
properties.putAll( addProps );
final Iterator keyIter = addProps.keySet().iterator();
while ( keyIter.hasNext() )
{
Object key = keyIter.next();
properties.remove(BUNDLE_PLUGIN_EXTENSION + key);
properties.remove(BUNDLE_PLUGIN_PREPEND_EXTENSION + key);
}
if (properties.getProperty("Bundle-Activator") != null
&& properties.getProperty("Bundle-Activator").isEmpty())
{
properties.remove("Bundle-Activator");
}
if (properties.containsKey("-disable-plugin"))
{
String[] disabled = properties.remove("-disable-plugin").toString().replaceAll(" ", "").split(",");
String[] enabled = properties.getProperty(Analyzer.PLUGIN, "").replaceAll(" ", "").split(",");
Set plugin = new LinkedHashSet();
plugin.addAll(Arrays.asList(enabled));
plugin.removeAll(Arrays.asList(disabled));
StringBuilder sb = new StringBuilder();
for (String s : plugin)
{
if (sb.length() > 0)
{
sb.append(",");
}
sb.append(s);
}
properties.setProperty(Analyzer.PLUGIN, sb.toString());
}
Builder builder = new Builder();
synchronized ( BundlePlugin.class ) // protect setBase...getBndLastModified which uses static DateFormat
{
builder.setBase( getBase( currentProject ) );
}
builder.setProperties( sanitize( properties ) );
if ( classpath != null )
{
builder.setClasspath( classpath );
}
return builder;
}
protected static Properties sanitize( Properties properties )
{
// convert any non-String keys/values to Strings
Properties sanitizedEntries = new Properties();
for ( Iterator> itr = properties.entrySet().iterator(); itr.hasNext(); )
{
Map.Entry entry = itr.next();
if ( entry.getKey() instanceof String == false )
{
String key = sanitize(entry.getKey());
if ( !properties.containsKey( key ) )
{
sanitizedEntries.setProperty( key, sanitize( entry.getValue() ) );
}
itr.remove();
}
else if ( entry.getValue() instanceof String == false )
{
entry.setValue( sanitize( entry.getValue() ) );
}
}
properties.putAll( sanitizedEntries );
return properties;
}
protected static String sanitize( Object value )
{
if ( value instanceof String )
{
return ( String ) value;
}
else if ( value instanceof Iterable )
{
String delim = "";
StringBuilder buf = new StringBuilder();
for ( Object i : ( Iterable ) value )
{
buf.append( delim ).append( i );
delim = ", ";
}
return buf.toString();
}
else if ( value.getClass().isArray() )
{
String delim = "";
StringBuilder buf = new StringBuilder();
for ( int i = 0, len = Array.getLength( value ); i < len; i++ )
{
buf.append( delim ).append( Array.get( value, i ) );
delim = ", ";
}
return buf.toString();
}
else
{
return String.valueOf( value );
}
}
protected void addMavenInstructions( MavenProject currentProject, DependencyNode dependencyGraph, Builder builder ) throws Exception
{
if ( currentProject.getBasedir() != null )
{
// update BND instructions to add included Maven resources
includeMavenResources(currentProject, builder, getLog());
// calculate default export/private settings based on sources
addLocalPackages(outputDirectory, builder);
// tell BND where the current project source resides
addMavenSourcePath(currentProject, builder, getLog());
}
// update BND instructions to embed selected Maven dependencies
Collection embeddableArtifacts = getEmbeddableArtifacts( currentProject, dependencyGraph, builder );
new DependencyEmbedder( getLog(), dependencyGraph, embeddableArtifacts ).processHeaders(builder);
if ( dumpInstructions != null || getLog().isDebugEnabled() )
{
StringBuilder buf = new StringBuilder();
getLog().debug( "BND Instructions:" + NL + dumpInstructions( builder.getProperties(), buf ) );
if ( dumpInstructions != null )
{
getLog().info( "Writing BND instructions to " + dumpInstructions );
dumpInstructions.getParentFile().mkdirs();
FileUtils.fileWrite( dumpInstructions, "# BND instructions" + NL + buf );
}
}
if ( dumpClasspath != null || getLog().isDebugEnabled() )
{
StringBuilder buf = new StringBuilder();
getLog().debug("BND Classpath:" + NL + dumpClasspath(builder.getClasspath(), buf));
if ( dumpClasspath != null )
{
getLog().info( "Writing BND classpath to " + dumpClasspath );
dumpClasspath.getParentFile().mkdirs();
FileUtils.fileWrite( dumpClasspath, "# BND classpath" + NL + buf );
}
}
}
protected Builder buildOSGiBundle( MavenProject currentProject, DependencyNode dependencyGraph, Map originalInstructions, Properties properties,
Jar[] classpath ) throws Exception
{
Builder builder = getOSGiBuilder( currentProject, originalInstructions, properties, classpath );
addMavenInstructions( currentProject, dependencyGraph, builder );
builder.build();
mergeMavenManifest(currentProject, dependencyGraph, builder);
return builder;
}
protected static StringBuilder dumpInstructions( Properties properties, StringBuilder buf )
{
try
{
buf.append( "#-----------------------------------------------------------------------" + NL );
Properties stringProperties = new Properties();
for ( Enumeration e = (Enumeration) properties.propertyNames(); e.hasMoreElements(); )
{
// we can only store String properties
String key = e.nextElement();
String value = properties.getProperty( key );
if ( value != null )
{
stringProperties.setProperty( key, value );
}
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
stringProperties.store( out, null ); // properties encoding is 8859_1
buf.append( out.toString( "8859_1" ) );
buf.append( "#-----------------------------------------------------------------------" + NL );
}
catch ( Throwable e )
{
// ignore...
}
return buf;
}
protected static StringBuilder dumpClasspath( List classpath, StringBuilder buf )
{
try
{
buf.append("#-----------------------------------------------------------------------" + NL);
buf.append( "-classpath:\\" + NL );
for ( Iterator i = classpath.iterator(); i.hasNext(); )
{
File path = i.next().getSource();
if ( path != null )
{
buf.append( ' ' + path.toString() + ( i.hasNext() ? ",\\" : "" ) + NL );
}
}
buf.append( "#-----------------------------------------------------------------------" + NL );
}
catch ( Throwable e )
{
// ignore...
}
return buf;
}
protected static StringBuilder dumpManifest( Manifest manifest, StringBuilder buf )
{
try
{
buf.append( "#-----------------------------------------------------------------------" + NL );
ByteArrayOutputStream out = new ByteArrayOutputStream();
ManifestWriter.outputManifest(manifest, out, true); // manifest encoding is UTF8
buf.append( out.toString( "UTF8" ) );
buf.append( "#-----------------------------------------------------------------------" + NL );
}
catch ( Throwable e )
{
// ignore...
}
return buf;
}
protected static void includeMavenResources( MavenProject currentProject, Analyzer analyzer, Log log )
{
// pass maven resource paths onto BND analyzer
final String mavenResourcePaths = getMavenResourcePaths( currentProject, false );
final String mavenTestResourcePaths = getMavenResourcePaths( currentProject, true );
final String includeResource = analyzer.getProperty( Analyzer.INCLUDE_RESOURCE );
if ( includeResource != null )
{
if ( includeResource.contains( MAVEN_RESOURCES ) || includeResource.contains( MAVEN_TEST_RESOURCES ) )
{
String combinedResource = StringUtils.replace( includeResource, MAVEN_RESOURCES, mavenResourcePaths );
combinedResource = StringUtils.replace( combinedResource, MAVEN_TEST_RESOURCES, mavenTestResourcePaths );
if ( combinedResource.length() > 0 )
{
analyzer.setProperty( Analyzer.INCLUDE_RESOURCE, combinedResource );
}
else
{
analyzer.unsetProperty( Analyzer.INCLUDE_RESOURCE );
}
}
else if ( mavenResourcePaths.length() > 0 )
{
log.warn( Analyzer.INCLUDE_RESOURCE + ": overriding " + mavenResourcePaths + " with " + includeResource
+ " (add " + MAVEN_RESOURCES + " if you want to include the maven resources)" );
}
}
else if ( mavenResourcePaths.length() > 0 )
{
analyzer.setProperty( Analyzer.INCLUDE_RESOURCE, mavenResourcePaths );
}
}
protected void mergeMavenManifest( MavenProject currentProject, DependencyNode dependencyGraph, Builder builder ) throws Exception
{
Jar jar = builder.getJar();
if ( getLog().isDebugEnabled() )
{
getLog().debug( "BND Manifest:" + NL + dumpManifest( jar.getManifest(), new StringBuilder() ) );
}
boolean addMavenDescriptor = currentProject.getBasedir() != null;
try
{
/*
* Grab customized manifest entries from the maven-jar-plugin configuration
*/
MavenArchiveConfiguration archiveConfig = JarPluginConfiguration.getArchiveConfiguration( currentProject );
String mavenManifestText = new MavenArchiver().getManifest( currentProject, archiveConfig ).toString();
addMavenDescriptor = addMavenDescriptor && archiveConfig.isAddMavenDescriptor();
Manifest mavenManifest = new Manifest();
// First grab the external manifest file (if specified and different to target location)
File externalManifestFile = archiveConfig.getManifestFile();
if ( null != externalManifestFile )
{
if ( !externalManifestFile.isAbsolute() )
{
externalManifestFile = new File( currentProject.getBasedir(), externalManifestFile.getPath() );
}
if ( externalManifestFile.exists() && !externalManifestFile.equals( new File( manifestLocation, "MANIFEST.MF" ) ) )
{
InputStream mis = new FileInputStream( externalManifestFile );
mavenManifest.read( mis );
mis.close();
}
}
// Then apply customized entries from the jar plugin; note: manifest encoding is UTF8
mavenManifest.read( new ByteArrayInputStream( mavenManifestText.getBytes( "UTF8" ) ) );
if ( !archiveConfig.isManifestSectionsEmpty() )
{
/*
* Add customized manifest sections (for some reason MavenArchiver doesn't do this for us)
*/
List sections = archiveConfig.getManifestSections();
for ( Iterator i = sections.iterator(); i.hasNext(); )
{
ManifestSection section = i.next();
Attributes attributes = new Attributes();
if ( !section.isManifestEntriesEmpty() )
{
Map entries = section.getManifestEntries();
for ( Iterator> j = entries.entrySet().iterator(); j.hasNext(); )
{
Map.Entry entry = j.next();
attributes.putValue( entry.getKey(), entry.getValue() );
}
}
mavenManifest.getEntries().put( section.getName(), attributes );
}
}
Attributes mainMavenAttributes = mavenManifest.getMainAttributes();
mainMavenAttributes.putValue( "Created-By", "Apache Maven Bundle Plugin" );
String[] removeHeaders = builder.getProperty( Constants.REMOVEHEADERS, "" ).split( "," );
// apply -removeheaders to the custom manifest
for ( int i = 0; i < removeHeaders.length; i++ )
{
for ( Iterator