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.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.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 1228837 2012-01-08 13:19:38Z rfscholte $

  * @goal ear

  * @phase package

  * @threadSafe

  * @requiresDependencyResolution test

  */

 public class EarMojo

     extends AbstractEarMojo

 {

     private static final String[] EMPTY_STRING_ARRAY = { };

     /**

      * Single directory for extra files to include in the EAR.

      *

      * @parameter default-value="${basedir}/src/main/application"

      * @required

      */

     private File earSourceDirectory;

     /**

      * The comma separated list of tokens to include in the EAR.

      *

      * @parameter alias="includes" default-value="**"

      */

     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.

      *

      * @parameter default-value="false"

      * @since 2.3.2

      */

     private boolean filtering;

     /**

      * Filters (property files) to include during the interpolation of the pom.xml.

      *

      * @parameter

      * @since 2.3.2

      */

     private List filters;

     /**

      * A list of file extensions that should not be filtered if

      * filtering is enabled.

      *

      * @parameter

      * @since 2.3.2

      */

     private List nonFilteredFileExtensions;

     /**

      * To escape interpolated value with Windows path

      * c:\foo\bar will be replaced with c:\\foo\\bar.

      *

      * @parameter expression="${maven.ear.escapedBackslashesInFilePath}" default-value="false"

      * @since 2.3.2

      */

     private boolean escapedBackslashesInFilePath;

     /**

      * Expression preceded with this String won't be interpolated

      * \${foo} will be replaced with ${foo}.

      *

      * @parameter expression="${maven.ear.escapeString}"

      * @since 2.3.2

      */

     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 default-value="${project.build.directory}"

      * @required

      */

     private String outputDirectory;

     /**

      * The name of the EAR file to generate.

      *

      * @parameter alias="earName" default-value="${project.build.finalName}"

      * @required

      */

     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).

      *

      * @parameter

      * @since 2.7

      */

     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[].

      *

      * @parameter

      * @since 2.7

      */

     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.

      *

      * @parameter expression="${maven.ear.skinnyWars}" default-value="false"

      * @since 2.7

      */

     private boolean skinnyWars;

     /**

      * The Jar archiver.

      *

      * @component role="org.codehaus.plexus.archiver.Archiver" role-hint="jar"

      */

     private JarArchiver jarArchiver;

     /**

      * The Zip archiver.

      *

      * @component role="org.codehaus.plexus.archiver.Archiver" role-hint="zip"

      */

     private ZipArchiver zipArchiver;

     /**

      * The Zip Un archiver.

      *

      * @component role="org.codehaus.plexus.archiver.UnArchiver" role-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="org.apache.maven.shared.filtering.MavenFileFilter" role-hint="default"

      * @required

      */

     private MavenFileFilter mavenFileFilter;

     /**

      * @component role="org.apache.maven.shared.filtering.MavenResourcesFiltering" role-hint="default"

      * @required

      */

     private MavenResourcesFiltering mavenResourcesFiltering;

     /**

      * @parameter expression="${session}"

      * @readonly

      * @required

      * @since 2.3.2

      */

     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( 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() );

         }

     }

 }