package org.apache.maven.plugin.ear;
/*
* 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.
*/
import org.apache.maven.archiver.MavenArchiveConfiguration;
import org.apache.maven.archiver.MavenArchiver;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.ear.util.EarMavenArchiver;
import org.apache.maven.plugin.ear.util.JavaEEVersion;
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.MavenProjectHelper;
import org.apache.maven.shared.filtering.MavenFileFilter;
import org.apache.maven.shared.filtering.MavenFilteringException;
import org.apache.maven.shared.filtering.MavenResourcesExecution;
import org.apache.maven.shared.filtering.MavenResourcesFiltering;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.UnArchiver;
import org.codehaus.plexus.archiver.jar.JarArchiver;
import org.codehaus.plexus.archiver.jar.Manifest;
import org.codehaus.plexus.archiver.jar.Manifest.Attribute;
import org.codehaus.plexus.archiver.jar.ManifestException;
import org.codehaus.plexus.archiver.manager.ArchiverManager;
import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
import org.codehaus.plexus.archiver.zip.ZipArchiver;
import org.codehaus.plexus.archiver.zip.ZipUnArchiver;
import org.codehaus.plexus.util.DirectoryScanner;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.StringUtils;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.zip.ZipException;
/**
* Builds J2EE Enterprise Archive (EAR) files.
*
* @author <a href="snicoll@apache.org">Stephane Nicoll</a>
* @version $Id: EarMojo.java 1359710 2012-07-10 14:53:53Z tchemit $
*/
@Mojo( name = "ear", defaultPhase = LifecyclePhase.PACKAGE, threadSafe = true,
requiresDependencyResolution = ResolutionScope.TEST )
public class EarMojo
extends AbstractEarMojo
{
private static final String[] EMPTY_STRING_ARRAY = { };
/**
* Single directory for extra files to include in the EAR.
*/
@Parameter( defaultValue = "${basedir}/src/main/application", required = true )
private File earSourceDirectory;
/**
* The comma separated list of tokens to include in the EAR.
*/
@Parameter( alias = "includes", defaultValue = "**" )
private String earSourceIncludes;
/**
* The comma separated list of tokens to exclude from the EAR.
*/
@Parameter( alias = "excludes" )
private String earSourceExcludes;
/**
* Specify that the EAR sources should be filtered.
*
* @since 2.3.2
*/
@Parameter( defaultValue = "false" )
private boolean filtering;
/**
* Filters (property files) to include during the interpolation of the pom.xml.
*
* @since 2.3.2
*/
@Parameter
private List filters;
/**
* A list of file extensions that should not be filtered if
* filtering is enabled.
*
* @since 2.3.2
*/
@Parameter
private List nonFilteredFileExtensions;
/**
* To escape interpolated value with Windows path
* c:\foo\bar will be replaced with c:\\foo\\bar.
*
* @since 2.3.2
*/
@Parameter( property = "maven.ear.escapedBackslashesInFilePath", defaultValue = "false" )
private boolean escapedBackslashesInFilePath;
/**
* Expression preceded with this String won't be interpolated
* \${foo} will be replaced with ${foo}.
*
* @since 2.3.2
*/
@Parameter( property = "maven.ear.escapeString" )
protected String escapeString;
/**
* The location of the manifest file to be used within the EAR file. If
* no value if specified, the default location in the workDirectory is
* taken. If the file does not exist, a manifest will be generated
* automatically.
*/
@Parameter
private File manifestFile;
/**
* The location of a custom application.xml file to be used
* within the EAR file.
*/
@Parameter
private String applicationXml;
/**
* The directory for the generated EAR.
*/
@Parameter( defaultValue = "${project.build.directory}", required = true )
private String outputDirectory;
/**
* The name of the EAR file to generate.
*/
@Parameter( alias = "earName", defaultValue = "${project.build.finalName}", required = true )
private String finalName;
/**
* The comma separated list of artifact's type(s) to unpack
* by default.
*/
@Parameter
private String unpackTypes;
/**
* Classifier to add to the artifact generated. If given, the artifact will
* be an attachment instead.
*/
@Parameter
private String classifier;
/**
* A comma separated list of tokens to exclude when packaging the EAR.
* By default nothing is excluded. Note that you can use the Java Regular
* Expressions engine to include and exclude specific pattern using the
* expression %regex[].
* Hint: read the about (?!Pattern).
*
* @since 2.7
*/
@Parameter
private String packagingExcludes;
/**
* A comma separated list of tokens to include when packaging the EAR.
* By default everything is included. Note that you can use the Java Regular
* Expressions engine to include and exclude specific pattern using the
* expression %regex[].
*
* @since 2.7
*/
@Parameter
private String packagingIncludes;
/**
* Whether to create skinny WARs or not. A skinny WAR is a WAR that does not
* have all of its dependencies in WEB-INF/lib. Instead those dependencies
* are shared between the WARs through the EAR.
*
* @since 2.7
*/
@Parameter( property = "maven.ear.skinnyWars", defaultValue = "false" )
private boolean skinnyWars;
/**
* The Jar archiver.
*/
@Component( role = Archiver.class, hint = "jar" )
private JarArchiver jarArchiver;
/**
* The Zip archiver.
*/
@Component( role = Archiver.class, hint = "zip" )
private ZipArchiver zipArchiver;
/**
* The Zip Un archiver.
*/
@Component( role = UnArchiver.class, hint = "zip" )
private ZipUnArchiver zipUnArchiver;
/**
* The archive configuration to use.
* See <a href="http://maven.apache.org/shared/maven-archiver/index.html">Maven Archiver Reference</a>.
*/
@Parameter
private MavenArchiveConfiguration archive = new MavenArchiveConfiguration();
/**
*/
@Component
private MavenProjectHelper projectHelper;
/**
* The archive manager.
*/
@Component
private ArchiverManager archiverManager;
/**
*/
@Component( role = MavenFileFilter.class, hint = "default" )
private MavenFileFilter mavenFileFilter;
/**
*/
@Component( role = MavenResourcesFiltering.class, hint = "default" )
private MavenResourcesFiltering mavenResourcesFiltering;
/**
* @since 2.3.2
*/
@Component
private MavenSession session;
private List filterWrappers;
public void execute()
throws MojoExecutionException, MojoFailureException
{
// Initializes ear modules
super.execute();
final JavaEEVersion javaEEVersion = JavaEEVersion.getJavaEEVersion( version );
// Initializes unpack types
List<String> unpackTypesList = new ArrayList<String>();
if ( unpackTypes != null )
{
unpackTypesList = Arrays.asList( unpackTypes.split( "," ) );
for ( String type : unpackTypesList )
{
if ( !EarModuleFactory.standardArtifactTypes.contains( type ) )
{
throw new MojoExecutionException(
"Invalid type [" + type + "] supported types are " + EarModuleFactory.standardArtifactTypes );
}
}
getLog().debug( "Initialized unpack types " + unpackTypesList );
}
// Copy modules
try
{
for ( EarModule module : getModules() )
{
if ( module instanceof JavaModule )
{
getLog().warn( "JavaModule is deprecated (" + module + "), please use JarModule instead." );
}
if ( module instanceof Ejb3Module )
{
getLog().warn( "Ejb3Module is deprecated (" + module + "), please use EjbModule instead." );
}
final File sourceFile = module.getArtifact().getFile();
final File destinationFile = buildDestinationFile( getWorkDirectory(), module.getUri() );
if ( !sourceFile.isFile() )
{
throw new MojoExecutionException(
"Cannot copy a directory: " + sourceFile.getAbsolutePath() + "; Did you package/install " +
module.getArtifact() + "?" );
}
if ( destinationFile.getCanonicalPath().equals( sourceFile.getCanonicalPath() ) )
{
getLog().info(
"Skipping artifact [" + module + "], as it already exists at [" + module.getUri() + "]" );
continue;
}
// If the module is within the unpack list, make sure that no unpack wasn't forced (null or true)
// If the module is not in the unpack list, it should be true
if ( ( unpackTypesList.contains( module.getType() ) &&
( module.shouldUnpack() == null || module.shouldUnpack().booleanValue() ) ) ||
( module.shouldUnpack() != null && module.shouldUnpack().booleanValue() ) )
{
getLog().info( "Copying artifact [" + module + "] to [" + module.getUri() + "] (unpacked)" );
// Make sure that the destination is a directory to avoid plexus nasty stuff :)
destinationFile.mkdirs();
unpack( sourceFile, destinationFile );
if ( skinnyWars && module.changeManifestClasspath() )
{
changeManifestClasspath( module, destinationFile );
}
}
else
{
if ( sourceFile.lastModified() > destinationFile.lastModified() )
{
getLog().info( "Copying artifact [" + module + "] to [" + module.getUri() + "]" );
FileUtils.copyFile( sourceFile, destinationFile );
if ( skinnyWars && module.changeManifestClasspath() )
{
changeManifestClasspath( module, destinationFile );
}
}
else
{
getLog().debug(
"Skipping artifact [" + module + "], as it is already up to date at [" + module.getUri() +
"]" );
}
}
}
}
catch ( IOException e )
{
throw new MojoExecutionException( "Error copying EAR modules", e );
}
catch ( ArchiverException e )
{
throw new MojoExecutionException( "Error unpacking EAR modules", e );
}
catch ( NoSuchArchiverException e )
{
throw new MojoExecutionException( "No Archiver found for EAR modules", e );
}
// Copy source files
try
{
File earSourceDir = earSourceDirectory;
if ( earSourceDir.exists() )
{
getLog().info( "Copy ear sources to " + getWorkDirectory().getAbsolutePath() );
String[] fileNames = getEarFiles( earSourceDir );
for ( int i = 0; i < fileNames.length; i++ )
{
copyFile( new File( earSourceDir, fileNames[i] ), new File( getWorkDirectory(), fileNames[i] ) );
}
}
if ( applicationXml != null && !"".equals( applicationXml ) )
{
//rename to application.xml
getLog().info( "Including custom application.xml[" + applicationXml + "]" );
File metaInfDir = new File( getWorkDirectory(), META_INF );
copyFile( new File( applicationXml ), new File( metaInfDir, "/application.xml" ) );
}
}
catch ( IOException e )
{
throw new MojoExecutionException( "Error copying EAR sources", e );
}
catch ( MavenFilteringException e )
{
throw new MojoExecutionException( "Error filtering EAR sources", e );
}
// Check if deployment descriptor is there
File ddFile = new File( getWorkDirectory(), APPLICATION_XML_URI );
if ( !ddFile.exists() && ( javaEEVersion.lt( JavaEEVersion.Five ) ) )
{
throw new MojoExecutionException(
"Deployment descriptor: " + ddFile.getAbsolutePath() + " does not exist." );
}
try
{
File earFile = getEarFile( outputDirectory, finalName, classifier );
final MavenArchiver archiver = new EarMavenArchiver( getModules() );
final JarArchiver jarArchiver = getJarArchiver();
getLog().debug( "Jar archiver implementation [" + jarArchiver.getClass().getName() + "]" );
archiver.setArchiver( jarArchiver );
archiver.setOutputFile( earFile );
// Include custom manifest if necessary
includeCustomManifestFile();
getLog().debug( "Excluding " + Arrays.asList( getPackagingExcludes() ) + " from the generated EAR." );
getLog().debug( "Including " + Arrays.asList( getPackagingIncludes() ) + " in the generated EAR." );
archiver.getArchiver().addDirectory( getWorkDirectory(), getPackagingIncludes(), getPackagingExcludes() );
archiver.createArchive( session, getProject(), archive );
if ( classifier != null )
{
projectHelper.attachArtifact( getProject(), "ear", classifier, earFile );
}
else
{
getProject().getArtifact().setFile( earFile );
}
}
catch ( Exception e )
{
throw new MojoExecutionException( "Error assembling EAR", e );
}
}
public String getApplicationXml()
{
return applicationXml;
}
public void setApplicationXml( String applicationXml )
{
this.applicationXml = applicationXml;
}
/**
* Returns a string array of the excludes to be used
* when assembling/copying the ear.
*
* @return an array of tokens to exclude
*/
protected String[] getExcludes()
{
@SuppressWarnings( "unchecked" ) List<String> excludeList =
new ArrayList<String>( FileUtils.getDefaultExcludesAsList() );
if ( earSourceExcludes != null && !"".equals( earSourceExcludes ) )
{
excludeList.addAll( Arrays.asList( StringUtils.split( earSourceExcludes, "," ) ) );
}
// if applicationXml is specified, omit the one in the source directory
if ( getApplicationXml() != null && !"".equals( getApplicationXml() ) )
{
excludeList.add( "**/" + META_INF + "/application.xml" );
}
return (String[]) excludeList.toArray( EMPTY_STRING_ARRAY );
}
/**
* Returns a string array of the includes to be used
* when assembling/copying the ear.
*
* @return an array of tokens to include
*/
protected String[] getIncludes()
{
return StringUtils.split( StringUtils.defaultString( earSourceIncludes ), "," );
}
public String[] getPackagingExcludes()
{
if ( StringUtils.isEmpty( packagingExcludes ) )
{
return new String[0];
}
else
{
return StringUtils.split( packagingExcludes, "," );
}
}
public void setPackagingExcludes( String packagingExcludes )
{
this.packagingExcludes = packagingExcludes;
}
public String[] getPackagingIncludes()
{
if ( StringUtils.isEmpty( packagingIncludes ) )
{
return new String[]{ "**" };
}
else
{
return StringUtils.split( packagingIncludes, "," );
}
}
public void setPackagingIncludes( String packagingIncludes )
{
this.packagingIncludes = packagingIncludes;
}
private static File buildDestinationFile( File buildDir, String uri )
{
return new File( buildDir, uri );
}
private void includeCustomManifestFile()
{
if ( manifestFile == null )
{
manifestFile = new File( getWorkDirectory(), "META-INF/MANIFEST.MF" );
}
if ( !manifestFile.exists() )
{
getLog().info( "Could not find manifest file: " + manifestFile + " - Generating one" );
}
else
{
getLog().info( "Including custom manifest file [" + manifestFile + "]" );
archive.setManifestFile( manifestFile );
}
}
/**
* Returns the EAR file to generate, based on an optional classifier.
*
* @param basedir the output directory
* @param finalName the name of the ear file
* @param classifier an optional classifier
* @return the EAR file to generate
*/
private static File getEarFile( String basedir, String finalName, String classifier )
{
if ( classifier == null )
{
classifier = "";
}
else if ( classifier.trim().length() > 0 && !classifier.startsWith( "-" ) )
{
classifier = "-" + classifier;
}
return new File( basedir, finalName + classifier + ".ear" );
}
/**
* Returns a list of filenames that should be copied
* over to the destination directory.
*
* @param sourceDir the directory to be scanned
* @return the array of filenames, relative to the sourceDir
*/
private String[] getEarFiles( File sourceDir )
{
DirectoryScanner scanner = new DirectoryScanner();
scanner.setBasedir( sourceDir );
scanner.setExcludes( getExcludes() );
scanner.addDefaultExcludes();
scanner.setIncludes( getIncludes() );
scanner.scan();
return scanner.getIncludedFiles();
}
/**
* Unpacks the module into the EAR structure.
*
* @param source File to be unpacked.
* @param destDir Location where to put the unpacked files.
*/
public void unpack( File source, File destDir )
throws NoSuchArchiverException, IOException, ArchiverException
{
UnArchiver unArchiver = archiverManager.getUnArchiver( "zip" );
unArchiver.setSourceFile( source );
unArchiver.setDestDirectory( destDir );
// Extract the module
unArchiver.extract();
}
/**
* Returns the {@link JarArchiver} implementation used
* to package the EAR file.
* <p/>
* By default the archiver is obtained from the Plexus container.
*
* @return the archiver
*/
protected JarArchiver getJarArchiver()
{
return jarArchiver;
}
private void copyFile( File source, File target )
throws MavenFilteringException, IOException, MojoExecutionException
{
if ( filtering && !isNonFilteredExtension( source.getName() ) )
{
// Silly that we have to do this ourselves
if ( target.getParentFile() != null && !target.getParentFile().exists() )
{
target.getParentFile().mkdirs();
}
mavenFileFilter.copyFile( source, target, true, getFilterWrappers(), null );
}
else
{
FileUtils.copyFile( source, target );
}
}
public boolean isNonFilteredExtension( String fileName )
{
return !mavenResourcesFiltering.filteredFileExtension( fileName, nonFilteredFileExtensions );
}
private List getFilterWrappers()
throws MojoExecutionException
{
if ( filterWrappers == null )
{
try
{
MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution();
mavenResourcesExecution.setEscapeString( escapeString );
filterWrappers =
mavenFileFilter.getDefaultFilterWrappers( project, filters, escapedBackslashesInFilePath,
this.session, mavenResourcesExecution );
}
catch ( MavenFilteringException e )
{
getLog().error( "Fail to build filtering wrappers " + e.getMessage() );
throw new MojoExecutionException( e.getMessage(), e );
}
}
return filterWrappers;
}
private void changeManifestClasspath( EarModule module, File original )
throws MojoFailureException
{
try
{
File workDirectory;
// Handle the case that the destination might be a directory (project-038)
if ( original.isFile() )
{
// Create a temporary work directory
workDirectory =
new File( new File( generatedDescriptorLocation, "temp" ), module.getArtifact().getArtifactId() );
workDirectory.mkdirs();
getLog().debug( "Created a temporary work directory: " + workDirectory.getAbsolutePath() );
// Unpack the archive to a temporary work directory
zipUnArchiver.setSourceFile( original );
zipUnArchiver.setDestDirectory( workDirectory );
zipUnArchiver.extract();
}
else
{
workDirectory = original;
}
// Create a META-INF/MANIFEST.MF file if it doesn't exist (project-038)
File metaInfDirectory = new File( workDirectory, "META-INF" );
boolean newMetaInfCreated = metaInfDirectory.mkdirs();
if ( newMetaInfCreated )
{
getLog().debug(
"This project did not have a META-INF directory before, so a new directory was created." );
}
File manifestFile = new File( metaInfDirectory, "MANIFEST.MF" );
boolean newManifestCreated = manifestFile.createNewFile();
if ( newManifestCreated )
{
getLog().debug(
"This project did not have a META-INF/MANIFEST.MF file before, so a new file was created." );
}
// Read the manifest from disk
Manifest mf = new Manifest( new FileReader( manifestFile ) );
Attribute classPath = mf.getMainSection().getAttribute( "Class-Path" );
List<String> classPathElements = new ArrayList<String>();
if ( classPath != null )
{
classPathElements.addAll( Arrays.asList( classPath.getValue().split( " " ) ) );
}
else
{
classPath = new Attribute( "Class-Path", "" );
mf.getMainSection().addConfiguredAttribute( classPath );
}
// Modify the classpath entries in the manifest
for ( EarModule o : getModules() )
{
if ( o instanceof JarModule )
{
JarModule jm = (JarModule) o;
if ( module.getLibDir() != null )
{
File artifact =
new File( new File( workDirectory, module.getLibDir() ), jm.getBundleFileName() );
if ( artifact.exists() )
{
if ( !artifact.delete() )
{
getLog().error( "Could not delete '" + artifact + "'" );
}
}
}
if ( classPathElements.contains( jm.getBundleFileName() ) )
{
classPathElements.set( classPathElements.indexOf( jm.getBundleFileName() ), jm.getUri() );
}
else
{
classPathElements.add( jm.getUri() );
}
}
}
classPath.setValue( StringUtils.join( classPathElements.iterator(), " " ) );
// Write the manifest to disk
PrintWriter pw = new PrintWriter( manifestFile );
mf.write( pw );
pw.close();
if ( original.isFile() )
{
// Pack up the archive again from the work directory
if ( !original.delete() )
{
getLog().error( "Could not delete original artifact file " + original );
}
getLog().debug( "Zipping module" );
zipArchiver.setDestFile( original );
zipArchiver.addDirectory( workDirectory );
zipArchiver.createArchive();
}
}
catch ( ManifestException e )
{
throw new MojoFailureException( e.getMessage() );
}
catch ( ZipException e )
{
throw new MojoFailureException( e.getMessage() );
}
catch ( IOException e )
{
throw new MojoFailureException( e.getMessage() );
}
catch ( ArchiverException e )
{
throw new MojoFailureException( e.getMessage() );
}
}
}