package org.apache.maven.plugin.assembly.mojos;

 /*

  * 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.artifact.repository.ArtifactRepository;

 import org.apache.maven.execution.MavenSession;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.plugin.assembly.AssemblerConfigurationSource;

 import org.apache.maven.plugin.assembly.InvalidAssemblerConfigurationException;

 import org.apache.maven.plugin.assembly.archive.ArchiveCreationException;

 import org.apache.maven.plugin.assembly.archive.AssemblyArchiver;

 import org.apache.maven.plugin.assembly.format.AssemblyFormattingException;

 import org.apache.maven.plugin.assembly.io.AssemblyReadException;

 import org.apache.maven.plugin.assembly.io.AssemblyReader;

 import org.apache.maven.plugin.assembly.model.Assembly;

 import org.apache.maven.plugin.assembly.utils.AssemblyFormatUtils;

 import org.apache.maven.plugin.logging.Log;

 import org.apache.maven.plugins.annotations.Component;

 import org.apache.maven.plugins.annotations.Parameter;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.project.MavenProjectHelper;

 import org.apache.maven.shared.filtering.MavenFileFilter;

 import org.codehaus.plexus.configuration.PlexusConfiguration;

 import java.io.File;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.List;

 /**

  * @author <a href="mailto:brett@apache.org">Brett Porter</a>

  * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>

  * @version $Id: AbstractAssemblyMojo.java 1401676 2012-10-24 13:43:25Z dennisl $

  * @threadSafe

  */

 public abstract class AbstractAssemblyMojo

     extends AbstractMojo

     implements AssemblerConfigurationSource

 {

     /**

      * The character encoding scheme to be applied when filtering resources.

      */

     @Parameter( property = "encoding", defaultValue = "${project.build.sourceEncoding}" )

     protected String encoding;

     /**

      * Expressions preceded with this String won't be interpolated.

      * If you use "\" as the escape string then \${foo} will be replaced with ${foo}.

      *

      * @since 2.4

      */

     @Parameter( property = "assembly.escapeString" )

     protected String escapeString;

     /**

      * Flag allowing one or more executions of the assembly plugin to be configured as skipped for a particular build.

      * This makes the assembly plugin more controllable from profiles.

      */

     @Parameter( property = "assembly.skipAssembly", defaultValue = "false" )

     private boolean skipAssembly;

     /**

      * If this flag is set, everything up to the call to Archiver.createArchive() will be executed.

      */

     @Parameter( property = "assembly.dryRun", defaultValue = "false" )

     private boolean dryRun;

     /**

      * If this flag is set, the ".dir" suffix will be suppressed in the output directory name when using assembly/format

      * == 'dir' and other formats that begin with 'dir'. <br/>

      * <b>NOTE:</b> Since 2.2-beta-3, the default-value for this is true, NOT false as it used to be.

      */

     @Parameter( defaultValue = "true" )

     private boolean ignoreDirFormatExtensions;

     /**

      * Local Maven repository where artifacts are cached during the build process.

      */

     @Parameter( defaultValue = "${localRepository}", required = true, readonly = true )

     private ArtifactRepository localRepository;

     /**

      */

     @Parameter( defaultValue = "${project.remoteArtifactRepositories}", required = true, readonly = true )

     private List<ArtifactRepository> remoteRepositories;

     /**

      * Contains the full list of projects in the reactor.

      */

     @Parameter( defaultValue = "${reactorProjects}", required = true, readonly = true )

     private List<MavenProject> reactorProjects;

     /**

      * The output directory of the assembled distribution file.

      */

     @Parameter( defaultValue = "${project.build.directory}", required = true )

     private File outputDirectory;

     /**

      * The filename of the assembled distribution file.

      */

     @Parameter( defaultValue = "${project.build.finalName}", required = true )

     private String finalName;

     /**

      * Directory to unpack JARs into if needed

      */

     @Parameter( defaultValue = "${project.build.directory}/assembly/work", required = true )

     private File workDirectory;

     /**

      * Specifies the formats of the assembly.

      * Multiple formats can be supplied and the Assembly Plugin will generate an archive for each desired formats.

      * When deploying your project, all file formats specified will also be deployed. A format is specified by supplying one of the following

      * values in a <format> subelement:

      * <ul>

      * <li><em>dir</em> - Creates a directory</li>

      * <li><em>zip</em> - Creates a ZIP file format</li>

      * <li><em>tar</em> - Creates a TAR format</li>

      * <li><em>tar.gz</em> - Creates a gzip'd TAR format</li>

      * <li><em>tar.bz2</em> - Creates a bzip'd TAR format</li>

      * </ul>

      */

     @Parameter

     private List<String> formats;

     /**

      * This is the artifact classifier to be used for the resultant assembly artifact. Normally, you would use the

      * assembly-id instead of specifying this here.

      *

      * @deprecated Please use the Assembly's id for classifier instead

      */

     @Deprecated

     @SuppressWarnings( "unused" )

     @Parameter( property = "classifier" )

     private String classifier;

     /**

      * A list of descriptor files to generate from.

      */

     @Parameter

     private String[] descriptors;

     /**

      * A list of references to assembly descriptors available on the plugin's classpath. The default classpath

      * includes these built-in descriptors: <code>bin</code>,

      * <code>jar-with-dependencies</code>, <code>src</code>, and

      * <code>project</code>. You can add others by adding dependencies

      * to the plugin.

      */

     @Parameter

     private String[] descriptorRefs;

     /**

      * Directory to scan for descriptor files in. <b>NOTE:</b> This may not work correctly with assembly components.

      */

     @Parameter

     private File descriptorSourceDirectory;

     /**

      * This is the base directory from which archive files are created. This base directory pre-pended to any

      * <code>&lt;directory&gt;</code> specifications in the assembly descriptor. This is an optional parameter.

      */

     @Parameter

     private File archiveBaseDirectory;

     /**

      * Predefined Assembly Descriptor Id's. You can select bin, jar-with-dependencies, or src.

      *

      * @deprecated Please use descriptorRefs instead

      */

     @Deprecated

     @Parameter( property = "descriptorId" )

     protected String descriptorId;

     /**

      * Assembly XML Descriptor file. This must be the path to your customized descriptor file.

      *

      * @deprecated Please use descriptors instead

      */

     @Deprecated

     @Parameter( property = "descriptor" )

     protected String descriptor;

     /**

      * Sets the TarArchiver behavior on file paths with more than 100 characters length. Valid values are: "warn"

      * (default), "fail", "truncate", "gnu", or "omit".

      */

     @Parameter( property = "assembly.tarLongFileMode", defaultValue = "warn" )

     private String tarLongFileMode;

     /**

      * Base directory of the project.

      */

     @Parameter( defaultValue = "${project.basedir}", required = true, readonly = true )

     private File basedir;

     /**

      * Maven ProjectHelper.

      */

     @Component

     private MavenProjectHelper projectHelper;

     /**

      * Maven shared filtering utility.

      */

     @Component

     private MavenFileFilter mavenFileFilter;

     /**

      * The Maven Session Object

      */

     @Component

     private MavenSession mavenSession;

     /**

      * Temporary directory that contain the files to be assembled.

      */

     @Parameter( defaultValue = "${project.build.directory}/archive-tmp", required = true, readonly = true )

     private File tempRoot;

     /**

      * Directory for site generated.

      */

     @Parameter( defaultValue = "${project.reporting.outputDirectory}", readonly = true )

     private File siteDirectory;

     /**

      * Set to true to include the site generated by site:site goal.

      *

      * @deprecated Please set this variable in the assembly descriptor instead

      */

     @Deprecated

     @Parameter( property = "includeSite", defaultValue = "false" )

     private boolean includeSite;

     /**

      * Set to false to exclude the assembly id from the assembly final name.

      */

     @Parameter( property = "assembly.appendAssemblyId", defaultValue = "true" )

     protected boolean appendAssemblyId;

     /**

      * Set to true in order to not fail when a descriptor is missing.

      */

     @Parameter( property = "assembly.ignoreMissingDescriptor", defaultValue = "false" )

     protected boolean ignoreMissingDescriptor;

     /**

      * This is a set of instructions to the archive builder, especially for building .jar files. It enables you to

      * specify a Manifest file for the jar, in addition to other options.

      */

     @Parameter

     private MavenArchiveConfiguration archive;

     /**

      * The list of extra filter properties files to be used along with System properties, project

      * properties, and filter properties files specified in the POM build/filters section, which

      * should be used for the filtering during the current mojo execution.

      * <br/>

      * Normally, these will be configured from a plugin's execution section, to provide a different

      * set of filters for a particular execution.

      */

     @Parameter

     protected List<String> filters;

     /**

      * Controls whether the assembly plugin tries to attach the resulting assembly to the project.

      *

      * @since 2.2-beta-1

      */

     @Parameter( property = "assembly.attach", defaultValue = "true" )

     private boolean attach;

     /**

      * Indicates if zip archives (jar,zip etc) being added to the assembly should be compressed again.

      * Compressing again can result in smaller archive size, but gives noticeably longer execution time.

      *

      * @since 2.4

      */

     @Parameter( defaultValue = "false" )

     private boolean recompressZippedFiles;

     /**

      */

     @Component

     private AssemblyArchiver assemblyArchiver;

     /**

      */

     @Component

     private AssemblyReader assemblyReader;

     /**

      * Allows additional configuration options that are specific to a particular type of archive format. This is

      * intended to capture an XML configuration that will be used to reflectively setup the options on the archiver

      * instance. <br/>

      * For instance, to direct an assembly with the "ear" format to use a particular deployment descriptor, you should

      * specify the following for the archiverConfig value in your plugin configuration: <br/>

      * <p/>

      * <pre>

      * <appxml>${project.basedir}/somepath/app.xml</appxml>

      * </pre>

      *

      * @since 2.2-beta-3

      */

     @Parameter

     private PlexusConfiguration archiverConfig;

     /**

      * This will cause the assembly to run only at the top of a given module tree. That is, run in the project contained

      * in the same folder where the mvn execution was launched.

      *

      * @since 2.2-beta-4

      */

     @Parameter( property = "assembly.runOnlyAtExecutionRoot", defaultValue = "false" )

     private boolean runOnlyAtExecutionRoot;

     /**

      * This will cause the assembly to only update an existing archive, if it exists.

      * <p>

      * <strong>Note:</strong> The property that can be used on the command line

      * was misspelled as "assembly.updatOnly" in versions prior to version 2.4.

      * </p>

      *

      * @since 2.2

      */

     @Parameter( property = "assembly.updateOnly", defaultValue = "false" )

     private boolean updateOnly;

     /**

      * <p>

      * will use the jvm chmod, this is available for user and all level group level will be ignored

      * </p>

      *

      * @since 2.2

      */

     @Parameter( property = "assembly.useJvmChmod", defaultValue = "false" )

     private boolean useJvmChmod;

     /**

      * <p>

      * Set to <code>true</code> in order to avoid all chmod calls.

      * </p>

      * <p/>

      * <p>

      * <b>NOTE:</b> This will cause the assembly plugin to <b>DISREGARD</b> all fileMode/directoryMode settings in the

      * assembly descriptor, and all file permissions in unpacked dependencies!

      * </p>

      *

      * @since 2.2

      */

     @Parameter( property = "assembly.ignorePermissions", defaultValue = "false" )

     private boolean ignorePermissions;

     /**

      * Create the binary distribution.

      * 

      * @throws org.apache.maven.plugin.MojoExecutionException

      * 

      */

     public void execute()

         throws MojoExecutionException, MojoFailureException

     {

         if ( skipAssembly )

         {

             getLog().info( "Assemblies have been skipped per configuration of the skipAssembly parameter." );

             return;

         }

         // run only at the execution root.

         if ( runOnlyAtExecutionRoot && !isThisTheExecutionRoot() )

         {

             getLog().info( "Skipping the assembly in this project because it's not the Execution Root" );

             return;

         }

         List<Assembly> assemblies;

         try

         {

             assemblies = assemblyReader.readAssemblies( this );

         }

         catch ( final AssemblyReadException e )

         {

             throw new MojoExecutionException( "Error reading assemblies: " + e.getMessage(), e );

         }

         catch ( final InvalidAssemblerConfigurationException e )

         {

             throw new MojoFailureException( assemblyReader, e.getMessage(), "Mojo configuration is invalid: "

                             + e.getMessage() );

         }

         // TODO: include dependencies marked for distribution under certain formats

         // TODO: how, might we plug this into an installer, such as NSIS?

         boolean warnedAboutMainProjectArtifact = false;

         for ( final Iterator<Assembly> assemblyIterator = assemblies.iterator(); assemblyIterator.hasNext(); )

         {

             final Assembly assembly = assemblyIterator.next();

             try

             {

                 final String fullName = AssemblyFormatUtils.getDistributionName( assembly, this );

                 List<String> effectiveFormats = formats;

                 if ( effectiveFormats == null || effectiveFormats.size() == 0 )

                 {

                     effectiveFormats = assembly.getFormats();

                 }

                 if ( effectiveFormats == null || effectiveFormats.size() == 0 ) 

                 {

                     throw new MojoFailureException( "No formats specified in the execution parameters or the assembly descriptor.");

                 }

                 for ( final String format : effectiveFormats )

                 {

                     final File destFile = assemblyArchiver.createArchive( assembly, fullName, format, this, isRecompressZippedFiles());

                     final MavenProject project = getProject();

                     final String classifier = getClassifier();

                     final String type = project.getArtifact()

                                                .getType();

                     if ( attach && destFile.isFile() )

                     {

                         if ( isAssemblyIdAppended() )

                         {

                             projectHelper.attachArtifact( project, format, assembly.getId(), destFile );

                         }

                         else if ( classifier != null )

                         {

                             projectHelper.attachArtifact( project, format, classifier, destFile );

                         }

                         else if ( !"pom".equals( type ) && format.equals( type ) )

                         {

                             if ( !warnedAboutMainProjectArtifact )

                             {

                                 final StringBuilder message = new StringBuilder();

                                 message.append( "Configuration options: 'appendAssemblyId' is set to false, and 'classifier' is missing." );

                                 message.append( "\nInstead of attaching the assembly file: " )

                                        .append( destFile )

                                        .append( ", it will become the file for main project artifact." );

                                 message.append( "\nNOTE: If multiple descriptors or descriptor-formats are provided for this project, the value of this file will be non-deterministic!" );

                                 getLog().warn( message );

                                 warnedAboutMainProjectArtifact = true;

                             }

                             final File existingFile = project.getArtifact()

                                                              .getFile();

                             if ( ( existingFile != null ) && existingFile.exists() )

                             {

                                 getLog().warn( "Replacing pre-existing project main-artifact file: " + existingFile

                                                                + "\nwith assembly file: " + destFile );

                             }

                             project.getArtifact()

                                    .setFile( destFile );

                         }

                         else

                         {

                             projectHelper.attachArtifact( project, format, null, destFile );

                         }

                     }

                     else if ( attach )

                     {

                         getLog().warn( "Assembly file: "

                                                        + destFile

                                                        + " is not a regular file (it may be a directory). It cannot be attached to the project build for installation or deployment." );

                     }

                 }

             }

             catch ( final ArchiveCreationException e )

             {

                 throw new MojoExecutionException( "Failed to create assembly: " + e.getMessage(), e );

             }

             catch ( final AssemblyFormattingException e )

             {

                 throw new MojoExecutionException( "Failed to create assembly: " + e.getMessage(), e );

             }

             catch ( final InvalidAssemblerConfigurationException e )

             {

                 throw new MojoFailureException( assembly, "Assembly is incorrectly configured: " + assembly.getId(),

                                                 "Assembly: " + assembly.getId() + " is not configured correctly: "

                                                                 + e.getMessage() );

             }

         }

     }

     /**

      * Returns true if the current project is located at the Execution Root Directory (where mvn was launched)

      * 

      * @return

      */

     protected boolean isThisTheExecutionRoot()

     {

         final Log log = getLog();

         log.debug( "Root Folder:" + mavenSession.getExecutionRootDirectory() );

         log.debug( "Current Folder:" + basedir );

         final boolean result = mavenSession.getExecutionRootDirectory()

                                            .equalsIgnoreCase( basedir.toString() );

         if ( result )

         {

             log.debug( "This is the execution root." );

         }

         else

         {

             log.debug( "This is NOT the execution root." );

         }

         return result;

     }

     protected AssemblyArchiver getAssemblyArchiver()

     {

         return assemblyArchiver;

     }

     protected AssemblyReader getAssemblyReader()

     {

         return assemblyReader;

     }

     public File getBasedir()

     {

         return basedir;

     }

     /**

      * {@inheritDoc}

      * 

      * @deprecated This has been replaced by {@link #getDescriptors()}

      */

     @Deprecated

     public String getDescriptor()

     {

         return descriptor;

     }

     /**

      * {@inheritDoc}

      * 

      * @deprecated This has been replaced by {@link #getDescriptorReferences()}

      */

     @Deprecated

     public String getDescriptorId()

     {

         return descriptorId;

     }

     public String[] getDescriptorReferences()

     {

         return descriptorRefs;

     }

     public File getDescriptorSourceDirectory()

     {

         return descriptorSourceDirectory;

     }

     public String[] getDescriptors()

     {

         return descriptors;

     }

     public abstract MavenProject getProject();

     public File getSiteDirectory()

     {

         return siteDirectory;

     }

     public boolean isSiteIncluded()

     {

         return includeSite;

     }

     public String getFinalName()

     {

         return finalName;

     }

     public boolean isAssemblyIdAppended()

     {

         return appendAssemblyId;

     }

     public String getTarLongFileMode()

     {

         return tarLongFileMode;

     }

     public File getOutputDirectory()

     {

         return outputDirectory;

     }

     public MavenArchiveConfiguration getJarArchiveConfiguration()

     {

         return archive;

     }

     public File getWorkingDirectory()

     {

         return workDirectory;

     }

     public ArtifactRepository getLocalRepository()

     {

         return localRepository;

     }

     public File getTemporaryRootDirectory()

     {

         return tempRoot;

     }

     public File getArchiveBaseDirectory()

     {

         return archiveBaseDirectory;

     }

     public List<String> getFilters()

     {

         if ( filters == null )

         {

             filters = getProject().getBuild()

                                   .getFilters();

             if ( filters == null )

             {

                 filters = Collections.emptyList();

             }

         }

         return filters;

     }

     public List<MavenProject> getReactorProjects()

     {

         return reactorProjects;

     }

     public String getClassifier()

     {

         // TODO Auto-generated method stub

         return null;

     }

     protected MavenProjectHelper getProjectHelper()

     {

         return projectHelper;

     }

     public void setAppendAssemblyId( final boolean appendAssemblyId )

     {

         this.appendAssemblyId = appendAssemblyId;

     }

     public void setArchive( final MavenArchiveConfiguration archive )

     {

         this.archive = archive;

     }

     public void setArchiveBaseDirectory( final File archiveBaseDirectory )

     {

         this.archiveBaseDirectory = archiveBaseDirectory;

     }

     public void setAssemblyArchiver( final AssemblyArchiver assemblyArchiver )

     {

         this.assemblyArchiver = assemblyArchiver;

     }

     public void setAssemblyReader( final AssemblyReader assemblyReader )

     {

         this.assemblyReader = assemblyReader;

     }

     public void setBasedir( final File basedir )

     {

         this.basedir = basedir;

     }

     public void setClassifier( final String classifier )

     {

         this.classifier = classifier;

     }

     /**

      * {@inheritDoc}

      * 

      * @deprecated This has been replaced by {@link #setDescriptors(String[])}

      */

     @Deprecated

     public void setDescriptor( final String descriptor )

     {

         this.descriptor = descriptor;

     }

     /**

      * {@inheritDoc}

      * 

      * @deprecated This has been replaced by {@link #setDescriptorRefs(String[])}

      */

     @Deprecated

     public void setDescriptorId( final String descriptorId )

     {

         this.descriptorId = descriptorId;

     }

     public void setDescriptorRefs( final String[] descriptorRefs )

     {

         this.descriptorRefs = descriptorRefs;

     }

     public void setDescriptors( final String[] descriptors )

     {

         this.descriptors = descriptors;

     }

     public void setDescriptorSourceDirectory( final File descriptorSourceDirectory )

     {

         this.descriptorSourceDirectory = descriptorSourceDirectory;

     }

     public void setFilters( final List<String> filters )

     {

         this.filters = filters;

     }

     public void setFinalName( final String finalName )

     {

         this.finalName = finalName;

     }

     public void setIncludeSite( final boolean includeSite )

     {

         this.includeSite = includeSite;

     }

     public void setLocalRepository( final ArtifactRepository localRepository )

     {

         this.localRepository = localRepository;

     }

     public void setOutputDirectory( final File outputDirectory )

     {

         this.outputDirectory = outputDirectory;

     }

     public void setProjectHelper( final MavenProjectHelper projectHelper )

     {

         this.projectHelper = projectHelper;

     }

     public void setReactorProjects( final List<MavenProject> reactorProjects )

     {

         this.reactorProjects = reactorProjects;

     }

     public void setSiteDirectory( final File siteDirectory )

     {

         this.siteDirectory = siteDirectory;

     }

     public void setTarLongFileMode( final String tarLongFileMode )

     {

         this.tarLongFileMode = tarLongFileMode;

     }

     public void setTempRoot( final File tempRoot )

     {

         this.tempRoot = tempRoot;

     }

     public void setWorkDirectory( final File workDirectory )

     {

         this.workDirectory = workDirectory;

     }

     public List<ArtifactRepository> getRemoteRepositories()

     {

         return remoteRepositories;

     }

     public boolean isDryRun()

     {

         return dryRun;

     }

     public boolean isIgnoreDirFormatExtensions()

     {

         return ignoreDirFormatExtensions;

     }

     public boolean isIgnoreMissingDescriptor()

     {

         return ignoreMissingDescriptor;

     }

     public void setIgnoreMissingDescriptor( final boolean ignoreMissingDescriptor )

     {

         this.ignoreMissingDescriptor = ignoreMissingDescriptor;

     }

     public MavenSession getMavenSession()

     {

         return mavenSession;

     }

     public String getArchiverConfig()

     {

         return archiverConfig == null ? null : archiverConfig.toString();

     }

     public MavenFileFilter getMavenFileFilter()

     {

         return mavenFileFilter;

     }

     public boolean isUpdateOnly()

     {

         return updateOnly;

     }

     public boolean isUseJvmChmod()

     {

         return useJvmChmod;

     }

     public boolean isIgnorePermissions()

     {

         return ignorePermissions;

     }

     public String getEncoding() {

         return encoding;

     }

     protected boolean isRecompressZippedFiles() {

         return recompressZippedFiles;

     }

     public String getEscapeString() {

       return escapeString;

     }

 }