Project: legacy-maven-support
/*
 * The MIT License 
 *  
 * Copyright (c) 2004-2010, Sun Microsystems, Inc., Kohsuke Kawaguchi, Olivier Lamy 
 *  
 * Permission is hereby granted, free of charge, to any person obtaining a copy 
 * of this software and associated documentation files (the "Software"), to deal 
 * in the Software without restriction, including without limitation the rights 
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 * copies of the Software, and to permit persons to whom the Software is 
 * furnished to do so, subject to the following conditions: 
 *  
 * The above copyright notice and this permission notice shall be included in 
 * all copies or substantial portions of the Software. 
 *  
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 * THE SOFTWARE. 
 */
package org.jvnet.hudson.maven3.agent; 
 
import java.io.BufferedInputStream; 
import java.io.BufferedOutputStream; 
import java.io.File; 
import java.io.FilterInputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.net.Socket; 
 
import org.codehaus.plexus.classworlds.launcher.Launcher; 
import org.codehaus.plexus.classworlds.realm.ClassRealm; 
 
 
 
/**
 * Entry point for launching Maven 3 and Hudson remoting in the same VM, in the 
 * classloader layout that Maven expects. 
 *  
 * <p> 
 * The actual Maven execution will be started by the program sent through 
 * remoting. 
 * </p> 
 *  
 * @author Kohsuke Kawaguchi 
 * @author Olivier Lamy 
 */ 
public class Maven3Main { 
 /**
  * Used to pass the classworld instance to the code running inside the 
  * remoting system. 
  */ 
 private static Launcher launcher; 
 
 public static void main(String[] args) throws Exception { 
  main(new File(args[0]), new File(args[1]),new File(args[2]), 
    Integer.parseInt(args[3]));   
 } 
 
 /**
  *  
  * @param m2Home 
  *            Maven2 installation. This is where we find Maven jars that 
  *            we'll run. 
  * @param remotingJar 
  *            Hudson's remoting.jar that we'll load. 
  * @param interceptorJar 
  *            maven-listener.jar that we'll load. 
  * @param tcpPort 
  *            TCP socket that the launching Hudson will be listening to. 
  *            This is used for the remoting communication. 
  * @param projectBuildLaunch 
  *            launch the projectBuilder and not a mavenExecution             
  */ 
 public static void main(File m2Home, File remotingJar, File interceptorJar, 
   int tcpPort) throws Exception { 
  // Unix master with Windows slave ends up passing path in Unix format, 
  // so convert it to Windows format now so that no one chokes with the 
  // path format later. 
  try { 
   m2Home = m2Home.getCanonicalFile(); 
  } catch (IOException e) { 
   // ignore. We'll check the error later if m2Home exists anyway 
  } 
 
  if (!m2Home.exists()) { 
   System.err.println("No such directory exists: " + m2Home); 
   System.exit(1); 
  } 
 
  versionCheck(); 
    
  // expose variables used in the classworlds configuration 
  System.setProperty("maven.home", m2Home.getPath()); 
                if (interceptorJar != null) { 
                    System.setProperty("maven3.interceptor", interceptorJar.getPath()); 
                } 
                 
  // load the default realms 
  launcher = new Launcher(); 
  launcher.setSystemClassLoader(Maven3Main.class.getClassLoader()); 
  launcher.configure(Maven3Main.class 
    .getResourceAsStream("classworlds.conf")); 
   
 
  // create a realm for loading remoting subsystem. 
  // this needs to be able to see maven. 
  ClassRealm remoting = launcher.getWorld().newRealm( "hudson-remoting", launcher.getSystemClassLoader() ); 
  remoting.setParentRealm(launcher.getWorld().getRealm("plexus.core")); 
  remoting.addURL(remotingJar.toURI().toURL()); 
   
  final Socket s = new Socket((String) null, tcpPort); 
   
  Class remotingLauncher = remoting.loadClass("hudson.remoting.Launcher"); 
  remotingLauncher.getMethod("main", 
    new Class[] { InputStream.class, OutputStream.class }).invoke( 
    null, 
    new Object[] { 
      // do partial close, since socket.getInputStream and 
      // getOutputStream doesn't do it by 
      new BufferedInputStream(new FilterInputStream(s 
        .getInputStream()) { 
       public void close() throws IOException { 
        s.shutdownInput(); 
       } 
      }), 
      new BufferedOutputStream(new RealFilterOutputStream(s 
        .getOutputStream()) { 
       public void close() throws IOException { 
        s.shutdownOutput(); 
       } 
      }) }); 
  System.exit(0); 
 } 
 
 /**
  * Called by the code in remoting to launch. 
  */ 
 public static int launch(String[] args) throws Exception { 
   
  try { 
   launcher.launch(args); 
  } catch (Throwable e) 
  { 
      e.printStackTrace(); 
      throw new Exception( e ); 
  }  
  return launcher.getExitCode(); 
 } 
  
    /**
     * Makes sure that this is Java5 or later. 
     */ 
    private static void versionCheck() { 
        String v = System.getProperty("java.class.version"); 
        if (v != null) { 
            try { 
                if (Float.parseFloat(v) < 49.0) { 
                    System.err 
                            .println("Native maven support requires Java 1.5 or later, but this Maven is using " 
                                    + System.getProperty("java.home")); 
                    System.err.println("Please use the freestyle project."); 
                    System.exit(1); 
                } 
            } catch (NumberFormatException e) { 
                // couldn't check. 
            } 
        } 
    }  
  
}