package org.apache.maven.plugin.surefire.booterclient;

 /*

  * 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.surefire.booter.ClassLoaderConfiguration;

 import org.apache.maven.surefire.booter.Classpath;

 import org.apache.maven.surefire.booter.ForkedBooter;

 import org.apache.maven.surefire.booter.SurefireBooterForkException;

 import org.apache.maven.surefire.util.Relocator;

 import org.apache.maven.surefire.util.UrlUtils;

 import org.codehaus.plexus.util.StringUtils;

 import org.codehaus.plexus.util.cli.Commandline;

 import java.io.File;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 import java.util.jar.JarEntry;

 import java.util.jar.JarOutputStream;

 import java.util.jar.Manifest;

 /**

  * Configuration for forking tests.

  *

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

  * @author <a href="mailto:kenney@apache.org">Kenney Westerhof</a>

  * @author <a href="mailto:krosenvold@apache.org">Kristian Rosenvold</a>

  */

 public class ForkConfiguration

 {

     public static final String FORK_ONCE = "once";

     public static final String FORK_ALWAYS = "always";

     public static final String FORK_NEVER = "never";

     private final Classpath bootClasspathConfiguration;

     private final String forkMode;

     private Properties systemProperties;

     private String jvmExecutable;

     private String argLine;

     private Map environmentVariables;

     private File workingDirectory;

     private File tempDirectory;

     private boolean debug;

     private String debugLine;

     public ForkConfiguration( Classpath bootClasspathConfiguration, String forkMode, File tmpDir )

     {

         this.bootClasspathConfiguration = bootClasspathConfiguration;

         this.forkMode = getForkMode( forkMode );

         this.tempDirectory = tmpDir;

     }

     public Classpath getBootClasspath()

     {

         return bootClasspathConfiguration;

     }

     private static String getForkMode( String forkMode )

     {

         if ( "pertest".equalsIgnoreCase( forkMode ) )

         {

             return FORK_ALWAYS;

         }

         else if ( "none".equalsIgnoreCase( forkMode ) )

         {

             return FORK_NEVER;

         }

         else if ( forkMode.equals( FORK_NEVER ) || forkMode.equals( FORK_ONCE ) || forkMode.equals( FORK_ALWAYS ) )

         {

             return forkMode;

         }

         else

         {

             throw new IllegalArgumentException( "Fork mode " + forkMode + " is not a legal value" );

         }

     }

     public boolean isForking()

     {

         return !FORK_NEVER.equals( forkMode );

     }

     public void setSystemProperties( Properties systemProperties )

     {

         this.systemProperties = (Properties) systemProperties.clone();

     }

     public void setJvmExecutable( String jvmExecutable )

     {

         this.jvmExecutable = jvmExecutable;

     }

     public void setArgLine( String argLine )

     {

         this.argLine = argLine;

     }

     public void setDebugLine( String debugLine )

     {

         this.debugLine = debugLine;

     }

     public void setEnvironmentVariables( Map environmentVariables )

     {

         this.environmentVariables = new HashMap( environmentVariables );

     }

     public void setWorkingDirectory( File workingDirectory )

     {

         this.workingDirectory = workingDirectory;

     }

     public void setTempDirectory( File tempDirectory )

     {

         this.tempDirectory = tempDirectory;

     }

     public String getForkMode()

     {

         return forkMode;

     }

     public Properties getSystemProperties()

     {

         return systemProperties;

     }

     /**

      * @param classPath              cla the classpath arguments

      * @param classpathConfiguration the classpath configuration

      * @param shadefire true if running shadefire

      * @return A commandline

      * @throws org.apache.maven.surefire.booter.SurefireBooterForkException

      *          when unable to perform the fork

      */

     public Commandline createCommandLine( List classPath, ClassLoaderConfiguration classpathConfiguration,

                                           boolean shadefire )

         throws SurefireBooterForkException

     {

         return createCommandLine( classPath, classpathConfiguration.isManifestOnlyJarRequestedAndUsable(), shadefire );

     }

     public Commandline createCommandLine( List classPath, boolean useJar, boolean shadefire )

         throws SurefireBooterForkException

     {

         Commandline cli = new Commandline();

         cli.setExecutable( jvmExecutable );

         if ( argLine != null )

         {

             cli.createArg().setLine( stripNewLines( argLine ) );

         }

         if ( environmentVariables != null )

         {

             Iterator iter = environmentVariables.keySet().iterator();

             while ( iter.hasNext() )

             {

                 String key = (String) iter.next();

                 String value = (String) environmentVariables.get( key );

                 cli.addEnvironment( key, value );

             }

         }

         if ( getDebugLine() != null && !"".equals( getDebugLine() ) )

         {

             cli.createArg().setLine( getDebugLine() );

         }

         if ( useJar )

         {

             File jarFile;

             try

             {

                 jarFile = createJar( classPath );

             }

             catch ( IOException e )

             {

                 throw new SurefireBooterForkException( "Error creating archive file", e );

             }

             cli.createArg().setValue( "-jar" );

             cli.createArg().setValue( jarFile.getAbsolutePath() );

         }

         else

         {

             cli.createArg().setValue( "-classpath" );

             cli.createArg().setValue( StringUtils.join( classPath.iterator(), File.pathSeparator ) );

             final String forkedBooter = ForkedBooter.class.getName();

             cli.createArg().setValue( shadefire ? new Relocator( ).relocate( forkedBooter ) : forkedBooter);

         }

         cli.setWorkingDirectory( workingDirectory.getAbsolutePath() );

         return cli;

     }

     /**

      * Create a jar with just a manifest containing a Main-Class entry for BooterConfiguration and a Class-Path entry

      * for all classpath elements.

      *

      * @param classPath List<String> of all classpath elements.

      * @return The file pointint to the jar

      * @throws java.io.IOException When a file operation fails.

      */

     public File createJar( List classPath )

         throws IOException

     {

         File file = File.createTempFile( "surefirebooter", ".jar", tempDirectory );

         if ( !debug )

         {

             file.deleteOnExit();

         }

         FileOutputStream fos = new FileOutputStream( file );

         JarOutputStream jos = new JarOutputStream( fos );

         jos.setLevel( JarOutputStream.STORED );

         JarEntry je = new JarEntry( "META-INF/MANIFEST.MF" );

         jos.putNextEntry( je );

         Manifest man = new Manifest();

         // we can't use StringUtils.join here since we need to add a '/' to

         // the end of directory entries - otherwise the jvm will ignore them.

         String cp = "";

         for ( Iterator it = classPath.iterator(); it.hasNext(); )

         {

             String el = (String) it.next();

             // NOTE: if File points to a directory, this entry MUST end in '/'.

             cp += UrlUtils.getURL( new File( el ) ).toExternalForm() + " ";

         }

         man.getMainAttributes().putValue( "Manifest-Version", "1.0" );

         man.getMainAttributes().putValue( "Class-Path", cp.trim() );

         man.getMainAttributes().putValue( "Main-Class", ForkedBooter.class.getName() );

         man.write( jos );

         jos.close();

         return file;

     }

     public void setDebug( boolean debug )

     {

         this.debug = debug;

     }

     public boolean isDebug()

     {

         return debug;

     }

     public String stripNewLines( String argline )

     {

         return argline.replace( "\n", " " ).replace( "\r", " " );

     }

     public String getDebugLine()

     {

         return debugLine;

     }

     public File getTempDirectory()

     {

         return tempDirectory;

     }

 }