package org.apache.tomcat.maven.plugin.tomcat7.run;

 /*

  * 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.commons.compress.archivers.ArchiveException;

 import org.apache.commons.compress.archivers.ArchiveOutputStream;

 import org.apache.commons.compress.archivers.ArchiveStreamFactory;

 import org.apache.commons.compress.archivers.jar.JarArchiveEntry;

 import org.apache.commons.io.FileUtils;

 import org.apache.commons.io.IOUtils;

 import org.apache.commons.lang.StringUtils;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.artifact.factory.ArtifactFactory;

 import org.apache.maven.artifact.repository.ArtifactRepository;

 import org.apache.maven.artifact.resolver.ArtifactNotFoundException;

 import org.apache.maven.artifact.resolver.ArtifactResolutionException;

 import org.apache.maven.artifact.resolver.ArtifactResolver;

 import org.apache.maven.model.Dependency;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 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.tomcat.maven.plugin.tomcat7.AbstractTomcat7Mojo;

 import org.apache.tomcat.maven.runner.Tomcat7Runner;

 import org.apache.tomcat.maven.runner.Tomcat7RunnerCli;

 import org.codehaus.plexus.archiver.jar.Manifest;

 import org.codehaus.plexus.archiver.jar.ManifestException;

 import org.codehaus.plexus.util.DirectoryScanner;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.OutputStream;

 import java.io.PrintWriter;

 import java.util.ArrayList;

 import java.util.Enumeration;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Properties;

 import java.util.jar.JarEntry;

 import java.util.jar.JarFile;

 /**

  * @author Olivier Lamy

  * @since 2.0

  */

 public abstract class AbstractExecWarMojo

     extends AbstractTomcat7Mojo

 {

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

     private Artifact projectArtifact;

     /**

      * The maven project.

      */

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

     protected MavenProject project;

     @Parameter (defaultValue = "${plugin.artifacts}", required = true)

     private List<Artifact> pluginArtifacts;

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

     private File buildDirectory;

     /**

      * Path under {@link #buildDirectory} where this mojo may do temporary work.

      */

     @Parameter (defaultValue = "${project.build.directory}/tomcat7-maven-plugin-exec")

     private File pluginWorkDirectory;

     @Parameter (property = "maven.tomcat.exec.war.tomcatConf", defaultValue = "src/main/tomcatconf")

     private File tomcatConfigurationFilesDirectory;

     @Parameter (defaultValue = "src/main/tomcatconf/server.xml", property = "maven.tomcat.exec.war.serverXml")

     private File serverXml;

     /**

      * Name of the generated exec JAR.

      */

     @Parameter (property = "tomcat.jar.finalName",

                 defaultValue = "${project.artifactId}-${project.version}-war-exec.jar", required = true)

     private String finalName;

     /**

      * The webapp context path to use for the web application being run.

      * The name to store webapp in exec jar. Do not use /

      */

     @Parameter (property = "maven.tomcat.path", defaultValue = "${project.artifactId}", required = true)

     protected String path;

     @Parameter

     protected List<WarRunDependency> warRunDependencies;

     @Component

     protected ArtifactResolver artifactResolver;

     /**

      * Maven Artifact Factory component.

      */

     @Component

     private ArtifactFactory artifactFactory;

     /**

      * Location of the local repository.

      */

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

     private ArtifactRepository local;

     /**

      * List of Remote Repositories used by the resolver

      */

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

     protected List<ArtifactRepository> remoteRepos;

     @Component

     private MavenProjectHelper projectHelper;

     /**

      * Attach or not the generated artifact to the build (use true if you want to install or deploy it)

      */

     @Parameter (property = "maven.tomcat.exec.war.attachArtifact", defaultValue = "true", required = true)

     private boolean attachArtifact;

     /**

      * the classifier to use for the attached/generated artifact

      */

     @Parameter (property = "maven.tomcat.exec.war.attachArtifactClassifier", defaultValue = "exec-war",

                 required = true)

     private String attachArtifactClassifier;

     /**

      * the type to use for the attached/generated artifact

      */

     @Parameter (property = "maven.tomcat.exec.war.attachArtifactType", defaultValue = "jar", required = true)

     private String attachArtifactClassifierType;

     /**

      * to enable naming when starting tomcat

      */

     @Parameter (property = "maven.tomcat.exec.war.enableNaming", defaultValue = "false", required = true)

     private boolean enableNaming;

     /**

      * see http://tomcat.apache.org/tomcat-7.0-doc/config/valve.html

      */

     @Parameter (property = "maven.tomcat.exec.war.accessLogValveFormat", defaultValue = "%h %l %u %t %r %s %b %I %D",

                 required = true)

     private String accessLogValveFormat;

     /**

      * list of extra dependencies to add in the standalone tomcat jar: your jdbc driver, mail.jar etc..

      * <b>Those dependencies will be in root classloader.</b>

      */

     @Parameter

     private List<ExtraDependency> extraDependencies;

     /**

      * list of extra resources to add in the standalone tomcat jar: your logger configuration etc

      */

     @Parameter

     private List<ExtraResource> extraResources;

     /**

      * Main class to use for starting the standalone jar.

      */

     @Parameter (property = "maven.tomcat.exec.war.mainClass",

                 defaultValue = "org.apache.tomcat.maven.runner.Tomcat7RunnerCli", required = true)

     private String mainClass;

     /**

      * which connector protocol to use HTTP/1.1 or org.apache.coyote.http11.Http11NioProtocol

      */

     @Parameter (property = "maven.tomcat.exec.war.connectorHttpProtocol", defaultValue = "HTTP/1.1", required = true)

     private String connectorHttpProtocol;

     public void execute()

         throws MojoExecutionException, MojoFailureException

     {

         //project.addAttachedArtifact(  );

         File warExecFile = new File( buildDirectory, finalName );

         if ( warExecFile.exists() )

         {

             warExecFile.delete();

         }

         File execWarJar = new File( buildDirectory, finalName );

         FileOutputStream execWarJarOutputStream = null;

         ArchiveOutputStream os = null;

         File tmpPropertiesFile = null;

         File tmpManifestFile = null;

         FileOutputStream tmpPropertiesFileOutputStream = null;

         PrintWriter tmpManifestWriter = null;

         try

         {

             tmpPropertiesFile = new File( buildDirectory, "war-exec.properties" );

             if ( tmpPropertiesFile.exists() )

             {

                 tmpPropertiesFile.delete();

             }

             tmpPropertiesFile.getParentFile().mkdirs();

             tmpManifestFile = new File( buildDirectory, "war-exec.manifest" );

             if ( tmpManifestFile.exists() )

             {

                 tmpManifestFile.delete();

             }

             tmpPropertiesFileOutputStream = new FileOutputStream( tmpPropertiesFile );

             execWarJar.getParentFile().mkdirs();

             execWarJar.createNewFile();

             execWarJarOutputStream = new FileOutputStream( execWarJar );

             tmpManifestWriter = new PrintWriter( tmpManifestFile );

             // store :

             //* wars in the root: foo.war

             //* tomcat jars

             //* file tomcat.standalone.properties with possible values :

             //   * useServerXml=true/false to use directly the one provided

             //   * enableNaming=true/false

             //   * wars=foo.war|contextpath;bar.war  ( |contextpath is optionnal if empty use the war name )

             //   * accessLogValveFormat=

             //   * connectorhttpProtocol: HTTP/1.1 or org.apache.coyote.http11.Http11NioProtocol

             //* optionnal: conf/ with usual tomcat configuration files

             //* MANIFEST with Main-Class

             Properties properties = new Properties();

             properties.put( Tomcat7Runner.ARCHIVE_GENERATION_TIMESTAMP_KEY,

                             Long.toString( System.currentTimeMillis() ) );

             properties.put( Tomcat7Runner.ENABLE_NAMING_KEY, Boolean.toString( enableNaming ) );

             properties.put( Tomcat7Runner.ACCESS_LOG_VALVE_FORMAT_KEY, accessLogValveFormat );

             properties.put( Tomcat7Runner.HTTP_PROTOCOL_KEY, connectorHttpProtocol );

             os = new ArchiveStreamFactory().createArchiveOutputStream( ArchiveStreamFactory.JAR,

                                                                        execWarJarOutputStream );

             if ( "war".equals( project.getPackaging() ) )

             {

                 os.putArchiveEntry( new JarArchiveEntry( StringUtils.removeStart( path, "/" ) + ".war" ) );

                 IOUtils.copy( new FileInputStream( projectArtifact.getFile() ), os );

                 os.closeArchiveEntry();

                 properties.put( Tomcat7Runner.WARS_KEY, StringUtils.removeStart( path, "/" ) + ".war|" + path );

             }

             else if ( warRunDependencies != null && !warRunDependencies.isEmpty() )

             {

                 for ( WarRunDependency warRunDependency : warRunDependencies )

                 {

                     if ( warRunDependency.dependency != null )

                     {

                         Dependency dependency = warRunDependency.dependency;

                         Artifact artifact = artifactFactory.createArtifactWithClassifier( dependency.getGroupId(),

                                                                                           dependency.getArtifactId(),

                                                                                           dependency.getVersion(),

                                                                                           dependency.getType(),

                                                                                           dependency.getClassifier() );

                         artifactResolver.resolve( artifact, this.remoteRepos, this.local );

                         File warFileToBundle = new File( resolvePluginWorkDir(), artifact.getFile().getName() );

                         FileUtils.copyFile( artifact.getFile(), warFileToBundle );

                         if ( warRunDependency.contextXml != null )

                         {

                             warFileToBundle = addContextXmlToWar( warRunDependency.contextXml, warFileToBundle );

                         }

                         final String warFileName = artifact.getFile().getName();

                         os.putArchiveEntry( new JarArchiveEntry( warFileName ) );

                         IOUtils.copy( new FileInputStream( warFileToBundle ), os );

                         os.closeArchiveEntry();

                         String propertyWarValue = properties.getProperty( Tomcat7Runner.WARS_KEY );

                         String contextPath =

                             StringUtils.isEmpty( warRunDependency.contextPath ) ? "/" : warRunDependency.contextPath;

                         if ( propertyWarValue != null )

                         {

                             properties.put( Tomcat7Runner.WARS_KEY,

                                             propertyWarValue + ";" + warFileName + "|" + contextPath );

                         }

                         else

                         {

                             properties.put( Tomcat7Runner.WARS_KEY, warFileName + "|" + contextPath );

                         }

                     }

                 }

             }

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

             {

                 os.putArchiveEntry( new JarArchiveEntry( "conf/server.xml" ) );

                 IOUtils.copy( new FileInputStream( serverXml ), os );

                 os.closeArchiveEntry();

                 properties.put( Tomcat7Runner.USE_SERVER_XML_KEY, Boolean.TRUE.toString() );

             }

             else

             {

                 properties.put( Tomcat7Runner.USE_SERVER_XML_KEY, Boolean.FALSE.toString() );

             }

             os.putArchiveEntry( new JarArchiveEntry( "conf/web.xml" ) );

             IOUtils.copy( getClass().getResourceAsStream( "/conf/web.xml" ), os );

             os.closeArchiveEntry();

             properties.store( tmpPropertiesFileOutputStream, "created by Apache Tomcat Maven plugin" );

             tmpPropertiesFileOutputStream.flush();

             tmpPropertiesFileOutputStream.close();

             os.putArchiveEntry( new JarArchiveEntry( Tomcat7RunnerCli.STAND_ALONE_PROPERTIES_FILENAME ) );

             IOUtils.copy( new FileInputStream( tmpPropertiesFile ), os );

             os.closeArchiveEntry();

             // add tomcat classes

             for ( Artifact pluginArtifact : pluginArtifacts )

             {

                 if ( StringUtils.equals( "org.apache.tomcat", pluginArtifact.getGroupId() ) || StringUtils.equals(

                     "org.apache.tomcat.embed", pluginArtifact.getGroupId() ) || StringUtils.equals(

                     "org.eclipse.jdt.core.compiler", pluginArtifact.getGroupId() ) || StringUtils.equals( "commons-cli",

                                                                                                           pluginArtifact.getArtifactId() )

                     || StringUtils.equals( "tomcat7-war-runner", pluginArtifact.getArtifactId() ) )

                 {

                     JarFile jarFile = new JarFile( pluginArtifact.getFile() );

                     Enumeration<JarEntry> jarEntries = jarFile.entries();

                     while ( jarEntries.hasMoreElements() )

                     {

                         JarEntry jarEntry = jarEntries.nextElement();

                         InputStream jarEntryIs = jarFile.getInputStream( jarEntry );

                         os.putArchiveEntry( new JarArchiveEntry( jarEntry.getName() ) );

                         IOUtils.copy( jarEntryIs, os );

                         os.closeArchiveEntry();

                     }

                 }

             }

             // add extra dependencies

             if ( extraDependencies != null && !extraDependencies.isEmpty() )

             {

                 for ( Dependency dependency : extraDependencies )

                 {

                     // String groupId, String artifactId, String version, String scope, String type

                     Artifact artifact =

                         artifactFactory.createArtifact( dependency.getGroupId(), dependency.getArtifactId(),

                                                         dependency.getVersion(), dependency.getScope(),

                                                         dependency.getType() );

                     artifactResolver.resolve( artifact, this.remoteRepos, this.local );

                     JarFile jarFile = new JarFile( artifact.getFile() );

                     Enumeration<JarEntry> jarEntries = jarFile.entries();

                     while ( jarEntries.hasMoreElements() )

                     {

                         JarEntry jarEntry = jarEntries.nextElement();

                         InputStream jarEntryIs = jarFile.getInputStream( jarEntry );

                         os.putArchiveEntry( new JarArchiveEntry( jarEntry.getName() ) );

                         IOUtils.copy( jarEntryIs, os );

                         os.closeArchiveEntry();

                     }

                 }

             }

             Manifest manifest = new Manifest();

             Manifest.Attribute mainClassAtt = new Manifest.Attribute();

             mainClassAtt.setName( "Main-Class" );

             mainClassAtt.setValue( mainClass );

             manifest.addConfiguredAttribute( mainClassAtt );

             manifest.write( tmpManifestWriter );

             tmpManifestWriter.flush();

             tmpManifestWriter.close();

             os.putArchiveEntry( new JarArchiveEntry( "META-INF/MANIFEST.MF" ) );

             IOUtils.copy( new FileInputStream( tmpManifestFile ), os );

             os.closeArchiveEntry();

             if ( attachArtifact )

             {

                 //MavenProject project, String artifactType, String artifactClassifier, File artifactFile

                 projectHelper.attachArtifact( project, attachArtifactClassifierType, attachArtifactClassifier,

                                               execWarJar );

             }

             if ( extraResources != null )

             {

                 for ( ExtraResource extraResource : extraResources )

                 {

                     DirectoryScanner directoryScanner = new DirectoryScanner();

                     directoryScanner.setBasedir( extraResource.getDirectory() );

                     directoryScanner.addDefaultExcludes();

                     directoryScanner.setExcludes( toStringArray( extraResource.getExcludes() ) );

                     directoryScanner.setIncludes( toStringArray( extraResource.getIncludes() ) );

                     directoryScanner.scan();

                     for ( String includeFile : directoryScanner.getIncludedFiles() )

                     {

                         getLog().debug( "include file:" + includeFile );

                         os.putArchiveEntry( new JarArchiveEntry( includeFile ) );

                         IOUtils.copy( new FileInputStream( new File( extraResource.getDirectory(), includeFile ) ),

                                       os );

                         os.closeArchiveEntry();

                     }

                 }

             }

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

             {

                 // Because its the tomcat default dir for configs

                 String aConfigOutputDir = "conf/";

                 copyDirectoryContentIntoArchive( tomcatConfigurationFilesDirectory, aConfigOutputDir, os );

             }

         }

         catch ( ManifestException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

         catch ( IOException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

         catch ( ArchiveException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

         catch ( ArtifactNotFoundException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

         catch ( ArtifactResolutionException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

         finally

         {

             IOUtils.closeQuietly( os );

             IOUtils.closeQuietly( tmpManifestWriter );

             IOUtils.closeQuietly( execWarJarOutputStream );

             IOUtils.closeQuietly( tmpPropertiesFileOutputStream );

         }

     }

     private void copyDirectoryContentIntoArchive( File pSourceFolder, String pDestinationPath,

                                                   ArchiveOutputStream pArchiveOutputSteam )

         throws FileNotFoundException, IOException

     {

         // Scan the directory

         DirectoryScanner directoryScanner = new DirectoryScanner();

         directoryScanner.setBasedir( pSourceFolder );

         directoryScanner.addDefaultExcludes();

         directoryScanner.scan();

         // Each File

         for ( String aIncludeFileName : directoryScanner.getIncludedFiles() )

         {

             getLog().debug( "include configuration file : " + pDestinationPath + aIncludeFileName );

             File aInputFile = new File( pSourceFolder, aIncludeFileName );

             FileInputStream aSourceFileInputStream = new FileInputStream( aInputFile );

             pArchiveOutputSteam.putArchiveEntry( new JarArchiveEntry( pDestinationPath + aIncludeFileName ) );

             IOUtils.copy( aSourceFileInputStream, pArchiveOutputSteam );

             pArchiveOutputSteam.closeArchiveEntry();

         }

     }

     /**

      * Resolves the plugin work dir as a sub directory of {@link #buildDirectory}, creating it if it does not exist.

      *

      * @return File representing the resolved plugin work dir

      * @throws MojoExecutionException if the plugin work dir cannot be created

      */

     protected File resolvePluginWorkDir()

         throws MojoExecutionException

     {

         if ( !pluginWorkDirectory.exists() && !pluginWorkDirectory.mkdirs() )

         {

             throw new MojoExecutionException(

                 "Could not create plugin work directory at " + pluginWorkDirectory.getAbsolutePath() );

         }

         return pluginWorkDirectory;

     }

     private String[] toStringArray( List list )

     {

         if ( list == null || list.isEmpty() )

         {

             return new String[0];

         }

         List<String> res = new ArrayList<String>( list.size() );

         for ( Iterator ite = list.iterator(); ite.hasNext(); )

         {

             res.add( (String) ite.next() );

         }

         return res.toArray( new String[res.size()] );

     }

     /**

      * return file can be deleted

      */

     private File addContextXmlToWar( File contextXmlFile, File warFile )

         throws IOException, ArchiveException

     {

         ArchiveOutputStream os = null;

         OutputStream warOutputStream = null;

         File tmpWar = File.createTempFile( "tomcat", "war-exec" );

         tmpWar.deleteOnExit();

         try

         {

             warOutputStream = new FileOutputStream( tmpWar );

             os = new ArchiveStreamFactory().createArchiveOutputStream( ArchiveStreamFactory.JAR, warOutputStream );

             os.putArchiveEntry( new JarArchiveEntry( "META-INF/context.xml" ) );

             IOUtils.copy( new FileInputStream( contextXmlFile ), os );

             os.closeArchiveEntry();

             JarFile jarFile = new JarFile( warFile );

             Enumeration<JarEntry> jarEntries = jarFile.entries();

             while ( jarEntries.hasMoreElements() )

             {

                 JarEntry jarEntry = jarEntries.nextElement();

                 os.putArchiveEntry( new JarArchiveEntry( jarEntry.getName() ) );

                 IOUtils.copy( jarFile.getInputStream( jarEntry ), os );

                 os.closeArchiveEntry();

             }

             os.flush();

         }

         finally

         {

             IOUtils.closeQuietly( os );

             IOUtils.closeQuietly( warOutputStream );

         }

         return tmpWar;

     }

 }