mirror of https://github.com/apache/maven.git
1288 lines
43 KiB
Java
1288 lines
43 KiB
Java
import compile.CompilerConfiguration;
|
|
import compile.JavacCompiler;
|
|
import download.ArtifactDownloader;
|
|
import download.RepositoryMetadata;
|
|
import jar.JarMojo;
|
|
import model.Dependency;
|
|
import model.ModelReader;
|
|
import model.Repository;
|
|
import org.xml.sax.Attributes;
|
|
import org.xml.sax.SAXException;
|
|
import test.SurefirePlugin;
|
|
import util.AbstractReader;
|
|
import util.Commandline;
|
|
import util.FileUtils;
|
|
import util.IsolatedClassLoader;
|
|
import util.Os;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import java.util.TreeMap;
|
|
|
|
public class MBoot
|
|
{
|
|
String[] builds = new String[]{"maven-model", "maven-settings", "maven-monitor", "maven-plugin-api",
|
|
"maven-artifact", "maven-plugin-descriptor", "maven-repository-metadata", "maven-artifact-manager",
|
|
"maven-artifact-test", "maven-script/maven-script-beanshell", "maven-script/maven-script-marmalade",
|
|
"maven-profile", "maven-project", "maven-plugin-registry", "maven-reporting/maven-reporting-api",
|
|
"maven-reporting/maven-reporting-impl", "maven-core", "maven-archiver",
|
|
"maven-plugin-tools/maven-plugin-tools-api", "maven-plugin-tools/maven-plugin-tools-java",
|
|
"maven-plugin-tools/maven-plugin-tools-beanshell", "maven-plugin-tools/maven-plugin-tools-pluggy",
|
|
"maven-plugin-tools/maven-plugin-tools-marmalade", "maven-core-it-verifier"};
|
|
|
|
String[] pluginBuilds = new String[]{"maven-plugins/maven-clean-plugin", "maven-plugins/maven-compiler-plugin",
|
|
"maven-plugins/maven-install-plugin", "maven-plugins/maven-jar-plugin", "maven-plugins/maven-plugin-plugin",
|
|
"maven-plugins/maven-resources-plugin", "maven-plugins/maven-surefire-plugin"};
|
|
|
|
private static final Map MODELLO_TARGET_VERSIONS;
|
|
|
|
private static final Map MODELLO_MODEL_FILES;
|
|
|
|
static
|
|
{
|
|
Map targetVersions = new TreeMap();
|
|
targetVersions.put( "maven-model", "4.0.0" );
|
|
targetVersions.put( "maven-settings", "1.0.0" );
|
|
targetVersions.put( "maven-profile", "1.0.0" );
|
|
targetVersions.put( "maven-plugin-registry", "1.0.0" );
|
|
targetVersions.put( "maven-plugin-descriptor", "1.0.0" );
|
|
targetVersions.put( "maven-repository-metadata", "1.0.0" );
|
|
|
|
MODELLO_TARGET_VERSIONS = Collections.unmodifiableMap( targetVersions );
|
|
|
|
Map modelFiles = new TreeMap();
|
|
modelFiles.put( "maven-model", "maven.mdo" );
|
|
modelFiles.put( "maven-settings", "settings.mdo" );
|
|
modelFiles.put( "maven-profile", "profiles.mdo" );
|
|
modelFiles.put( "maven-plugin-registry", "plugin-registry.mdo" );
|
|
modelFiles.put( "maven-plugin-descriptor", "src/main/mdo/lifecycle.mdo" );
|
|
modelFiles.put( "maven-repository-metadata", "src/main/mdo/metadata.mdo" );
|
|
|
|
MODELLO_MODEL_FILES = Collections.unmodifiableMap( modelFiles );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Standard locations for resources in Maven projects.
|
|
// ----------------------------------------------------------------------
|
|
|
|
private static final String SOURCES = "src/main/java";
|
|
|
|
private static final String TEST_SOURCES = "src/test/java";
|
|
|
|
private static final String RESOURCES = "src/main/resources";
|
|
|
|
private static final String TEST_RESOURCES = "src/test/resources";
|
|
|
|
private static final String BUILD_DIR = "target";
|
|
|
|
private static final String CLASSES = BUILD_DIR + "/classes";
|
|
|
|
private static final String TEST_CLASSES = BUILD_DIR + "/test-classes";
|
|
|
|
private static final String GENERATED_SOURCES = BUILD_DIR + "/generated-sources";
|
|
|
|
private static final String GENERATED_DOCS = BUILD_DIR + "/generated-docs";
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Per-session entities which we can reuse while building many projects.
|
|
// ----------------------------------------------------------------------
|
|
|
|
private ArtifactDownloader downloader;
|
|
|
|
private boolean online = true;
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// ----------------------------------------------------------------------
|
|
|
|
public static void main( String[] args )
|
|
throws Exception
|
|
{
|
|
try
|
|
{
|
|
MBoot mboot = new MBoot();
|
|
|
|
mboot.run( args );
|
|
}
|
|
catch ( InvocationTargetException e )
|
|
{
|
|
Throwable target = e.getTargetException();
|
|
|
|
if ( target instanceof RuntimeException )
|
|
{
|
|
throw (RuntimeException) target;
|
|
}
|
|
else if ( target instanceof Exception )
|
|
{
|
|
throw (Exception) target;
|
|
}
|
|
else
|
|
{
|
|
throw new RuntimeException( target );
|
|
}
|
|
}
|
|
}
|
|
|
|
public void run( String[] args )
|
|
throws Exception
|
|
{
|
|
String mavenRepoLocal = System.getProperty( "maven.repo.local" );
|
|
|
|
SettingsReader userModelReader = new SettingsReader();
|
|
|
|
String userHome = System.getProperty( "user.home" );
|
|
|
|
File settingsXml = new File( userHome, ".m2/settings.xml" );
|
|
|
|
if ( settingsXml.exists() )
|
|
{
|
|
userModelReader.parse( settingsXml );
|
|
|
|
if ( mavenRepoLocal == null )
|
|
{
|
|
// user don't override mavenRepoLocal with maven.repo.local system property
|
|
mavenRepoLocal = userModelReader.getLocalRepository();
|
|
}
|
|
}
|
|
|
|
if ( mavenRepoLocal == null )
|
|
{
|
|
String m2LocalRepoPath = "/.m2/repository";
|
|
|
|
File repoDir = new File( userHome, m2LocalRepoPath );
|
|
if ( !repoDir.exists() )
|
|
{
|
|
repoDir.mkdirs();
|
|
}
|
|
|
|
mavenRepoLocal = repoDir.getAbsolutePath();
|
|
|
|
System.out.println(
|
|
"You SHOULD have a ~/.m2/settings.xml file and must contain at least the following information:" );
|
|
System.out.println();
|
|
|
|
System.out.println( "<settings>" );
|
|
System.out.println( " <localRepository>/path/to/your/repository</localRepository>" );
|
|
System.out.println( "</settings>" );
|
|
|
|
System.out.println();
|
|
|
|
System.out.println( "Alternatively, you can specify -Dmaven.repo.local=/path/to/m2/repository" );
|
|
|
|
System.out.println();
|
|
|
|
System.out.println( "HOWEVER, since you did not specify a repository path, maven will use: " +
|
|
repoDir.getAbsolutePath() + " to store artifacts locally." );
|
|
}
|
|
|
|
File repoLocalFile = new File( mavenRepoLocal );
|
|
repoLocalFile.mkdirs();
|
|
|
|
if ( !repoLocalFile.canWrite() )
|
|
{
|
|
System.err.println( "Can't write to " + mavenRepoLocal );
|
|
|
|
System.exit( 1 );
|
|
}
|
|
|
|
String mavenHome = null;
|
|
|
|
if ( args.length == 1 )
|
|
{
|
|
mavenHome = args[0];
|
|
}
|
|
else
|
|
{
|
|
mavenHome = System.getProperty( "maven.home" );
|
|
|
|
if ( mavenHome == null )
|
|
{
|
|
mavenHome = new File( System.getProperty( "user.home" ), "m2" ).getAbsolutePath();
|
|
}
|
|
}
|
|
|
|
File dist = new File( mavenHome );
|
|
|
|
System.out.println( "Maven installation directory: " + dist );
|
|
|
|
if ( dist.exists() )
|
|
{
|
|
if ( !new File( dist, "bin/m2.conf" ).exists() )
|
|
{
|
|
System.err.println(
|
|
"The directory given to install Maven in already exists, but does not contain a Maven installation" );
|
|
System.err.println();
|
|
System.err.println( "\t" + dist );
|
|
System.err.println();
|
|
System.err.println(
|
|
"If you really mean to install Maven to this location, please delete the directory first" );
|
|
System.exit( 1 );
|
|
}
|
|
}
|
|
|
|
Date fullStop;
|
|
|
|
Date fullStart = new Date();
|
|
|
|
String onlineProperty = System.getProperty( "maven.online" );
|
|
|
|
if ( onlineProperty != null && onlineProperty.equals( "false" ) )
|
|
{
|
|
online = false;
|
|
}
|
|
|
|
Repository localRepository = new Repository( "local", mavenRepoLocal, Repository.LAYOUT_DEFAULT, false, false );
|
|
|
|
if ( online )
|
|
{
|
|
downloader = new ArtifactDownloader( localRepository );
|
|
if ( userModelReader.getActiveProxy() != null )
|
|
{
|
|
Proxy proxy = userModelReader.getActiveProxy();
|
|
downloader.setProxy( proxy.getHost(), proxy.getPort(), proxy.getUserName(), proxy.getPassword() );
|
|
}
|
|
|
|
List remoteRepos = downloader.getRemoteRepositories();
|
|
List newRemoteRepos = new ArrayList();
|
|
|
|
for ( Iterator i = remoteRepos.iterator(); i.hasNext(); )
|
|
{
|
|
Repository repo = (Repository) i.next();
|
|
|
|
boolean foundMirror = false;
|
|
for ( Iterator j = userModelReader.getMirrors().iterator(); j.hasNext() && !foundMirror; )
|
|
{
|
|
Mirror m = (Mirror) j.next();
|
|
if ( m.getMirrorOf().equals( repo.getId() ) )
|
|
{
|
|
newRemoteRepos.add( new Repository( m.getId(), m.getUrl(), repo.getLayout(), repo.isSnapshots(),
|
|
repo.isReleases() ) );
|
|
foundMirror = true;
|
|
}
|
|
}
|
|
if ( !foundMirror )
|
|
{
|
|
newRemoteRepos.add( repo );
|
|
}
|
|
}
|
|
|
|
downloader.setRemoteRepositories( newRemoteRepos );
|
|
|
|
System.out.println( "Using the following for your local repository: " + localRepository );
|
|
System.out.println( "Using the following for your remote repository: " + newRemoteRepos );
|
|
}
|
|
|
|
String basedir = System.getProperty( "user.dir" );
|
|
|
|
// Install maven-components POM
|
|
installPomFile( localRepository, new File( basedir, "pom.xml" ) );
|
|
|
|
// Install plugin-parent POM
|
|
installPomFile( localRepository, new File( basedir, "maven-plugins/pom.xml" ) );
|
|
|
|
// Install plugin-tools-parent POM
|
|
installPomFile( localRepository, new File( basedir, "maven-plugin-tools/pom.xml" ) );
|
|
|
|
// Install maven-script-parent POM
|
|
installPomFile( localRepository, new File( basedir, "maven-script/pom.xml" ) );
|
|
|
|
// Install maven-reporting parent POM
|
|
installPomFile( localRepository, new File( basedir, "maven-reporting/pom.xml" ) );
|
|
|
|
ModelReader reader = new ModelReader( downloader, true );
|
|
|
|
reader.parse( new File( basedir, "maven-mboot2/pom.xml" ) );
|
|
|
|
ClassLoader bootstrapClassLoader = createClassloaderFromDependencies( reader.getDependencies(), null,
|
|
localRepository );
|
|
|
|
reader = new ModelReader( downloader, false );
|
|
reader.parse( new File( basedir, "maven-plugins/maven-surefire-plugin/pom.xml" ) );
|
|
List surefireDependencies = new ArrayList();
|
|
|
|
// while we have maven-artifact in there, it needs to be filtered...
|
|
for ( Iterator i = reader.getDependencies().iterator(); i.hasNext(); )
|
|
{
|
|
Dependency d = (Dependency) i.next();
|
|
if ( "surefire".equals( d.getGroupId() ) || "junit".equals( d.getGroupId() ) )
|
|
{
|
|
surefireDependencies.add( d );
|
|
}
|
|
}
|
|
|
|
if ( online )
|
|
{
|
|
downloader.downloadDependencies( surefireDependencies );
|
|
}
|
|
|
|
reader = new ModelReader( downloader, true );
|
|
|
|
Collection coreDeps = null;
|
|
Dependency corePom = null;
|
|
|
|
for ( int i = 0; i < builds.length; i++ )
|
|
{
|
|
String directory = new File( basedir, builds[i] ).getAbsolutePath();
|
|
|
|
System.out.println( "Building project in " + directory + " ..." );
|
|
|
|
System.out.println( "--------------------------------------------------------------------" );
|
|
|
|
System.setProperty( "basedir", directory );
|
|
|
|
reader = buildProject( directory, builds[i], bootstrapClassLoader, surefireDependencies, localRepository );
|
|
|
|
if ( reader.getArtifactId().equals( "maven-core" ) )
|
|
{
|
|
coreDeps = reader.getDependencies();
|
|
corePom = new Dependency( reader.getGroupId(), reader.getArtifactId(), reader.getVersion(),
|
|
reader.getPackaging() );
|
|
}
|
|
|
|
System.out.println( "--------------------------------------------------------------------" );
|
|
}
|
|
|
|
reader = new ModelReader( downloader, true );
|
|
reader.parse( new File( basedir, "maven-plugin-tools/maven-plugin-tools-pluggy/pom.xml" ) );
|
|
List dependencies = new ArrayList( reader.getDependencies() );
|
|
dependencies.add(
|
|
new Dependency( reader.getGroupId(), reader.getArtifactId(), reader.getVersion(), reader.getPackaging() ) );
|
|
IsolatedClassLoader cl = createClassloaderFromDependencies( dependencies, bootstrapClassLoader,
|
|
localRepository );
|
|
|
|
for ( int i = 0; i < pluginBuilds.length; i++ )
|
|
{
|
|
String directory = new File( basedir, pluginBuilds[i] ).getAbsolutePath();
|
|
|
|
System.out.println( "Building project in " + directory + " ..." );
|
|
|
|
System.out.println( "--------------------------------------------------------------------" );
|
|
|
|
System.setProperty( "basedir", directory );
|
|
|
|
reader = buildProject( directory, pluginBuilds[i], cl, surefireDependencies, localRepository );
|
|
|
|
System.out.println( "--------------------------------------------------------------------" );
|
|
}
|
|
|
|
// build the installation
|
|
FileUtils.deleteDirectory( dist );
|
|
|
|
// ----------------------------------------------------------------------
|
|
// bin
|
|
// ----------------------------------------------------------------------
|
|
|
|
String bin = new File( dist, "bin" ).getAbsolutePath();
|
|
|
|
FileUtils.mkdir( new File( bin ).getPath() );
|
|
|
|
FileUtils.copyFileToDirectory( new File( basedir, "maven-core/src/bin/m2" ).getAbsolutePath(), bin );
|
|
|
|
FileUtils.copyFileToDirectory( new File( basedir, "maven-core/src/bin/m2.bat" ).getAbsolutePath(), bin );
|
|
|
|
FileUtils.copyFileToDirectory( new File( basedir, "maven-core/src/bin/m2.conf" ).getAbsolutePath(), bin );
|
|
|
|
if ( Os.isFamily( "unix" ) )
|
|
{
|
|
Commandline cli = new Commandline();
|
|
|
|
cli.setExecutable( "chmod" );
|
|
|
|
cli.createArgument().setValue( "+x" );
|
|
|
|
cli.createArgument().setValue( new File( dist, "bin/m2" ).getAbsolutePath() );
|
|
|
|
cli.execute().waitFor();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// core
|
|
// ----------------------------------------------------------------------
|
|
|
|
File core = new File( dist, "core" );
|
|
|
|
core.mkdirs();
|
|
|
|
File boot = new File( dist, "core/boot" );
|
|
|
|
boot.mkdirs();
|
|
|
|
// ----------------------------------------------------------------------
|
|
// lib
|
|
// ----------------------------------------------------------------------
|
|
|
|
File lib = new File( dist, "lib" );
|
|
|
|
lib.mkdirs();
|
|
|
|
for ( Iterator i = coreDeps.iterator(); i.hasNext(); )
|
|
{
|
|
Dependency d = (Dependency) i.next();
|
|
|
|
File source = localRepository.getArtifactFile( d );
|
|
if ( d.getArtifactId().equals( "classworlds" ) )
|
|
{
|
|
FileUtils.copyFileToDirectory( source, boot );
|
|
}
|
|
else if ( d.getArtifactId().equals( "plexus-container-default" ) ||
|
|
d.getArtifactId().equals( "plexus-utils" ) )
|
|
{
|
|
FileUtils.copyFileToDirectory( source, core );
|
|
}
|
|
else if ( !d.getScope().equals( Dependency.SCOPE_TEST ) )
|
|
{
|
|
// only compile and runtime
|
|
FileUtils.copyFileToDirectory( source, lib );
|
|
}
|
|
}
|
|
|
|
// Copy maven itself
|
|
FileUtils.copyFileToDirectory( localRepository.getArtifactFile( corePom ), lib );
|
|
|
|
System.out.println();
|
|
|
|
System.out.println( "Maven2 is installed in " + dist.getAbsolutePath() );
|
|
|
|
System.out.println( "--------------------------------------------------------------------" );
|
|
|
|
System.out.println();
|
|
|
|
fullStop = new Date();
|
|
|
|
stats( fullStart, fullStop );
|
|
}
|
|
|
|
protected static String formatTime( long ms )
|
|
{
|
|
long secs = ms / 1000;
|
|
|
|
long min = secs / 60;
|
|
secs = secs % 60;
|
|
|
|
if ( min > 0 )
|
|
{
|
|
return min + " minutes " + secs + " seconds";
|
|
}
|
|
else
|
|
{
|
|
return secs + " seconds";
|
|
}
|
|
}
|
|
|
|
private void stats( Date fullStart, Date fullStop )
|
|
{
|
|
long fullDiff = fullStop.getTime() - fullStart.getTime();
|
|
|
|
System.out.println( "Total time: " + formatTime( fullDiff ) );
|
|
|
|
System.out.println( "Finished at: " + fullStop );
|
|
}
|
|
|
|
private ModelReader buildProject( String basedir, String projectId, ClassLoader classLoader,
|
|
List surefireDependencies, Repository localRepository )
|
|
throws Exception
|
|
{
|
|
System.out.println( "Building project in " + basedir );
|
|
|
|
ModelReader reader = new ModelReader( downloader, true );
|
|
|
|
reader.parse( new File( basedir, "pom.xml" ) );
|
|
|
|
String sources = new File( basedir, SOURCES ).getAbsolutePath();
|
|
|
|
String resources = new File( basedir, RESOURCES ).getAbsolutePath();
|
|
|
|
String classes = new File( basedir, CLASSES ).getAbsolutePath();
|
|
|
|
String testSources = new File( basedir, TEST_SOURCES ).getAbsolutePath();
|
|
|
|
String testResources = new File( basedir, TEST_RESOURCES ).getAbsolutePath();
|
|
|
|
String testClasses = new File( basedir, TEST_CLASSES ).getAbsolutePath();
|
|
|
|
String generatedSources = new File( basedir, GENERATED_SOURCES ).getAbsolutePath();
|
|
|
|
File buildDirFile = new File( basedir, BUILD_DIR );
|
|
String buildDir = buildDirFile.getAbsolutePath();
|
|
|
|
// clean
|
|
System.out.println( "Cleaning " + buildDirFile + "..." );
|
|
FileUtils.forceDelete( buildDirFile );
|
|
|
|
if ( online )
|
|
{
|
|
System.out.println( "Downloading project dependencies ..." );
|
|
|
|
downloader.downloadDependencies( reader.getDependencies() );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Generating sources
|
|
// ----------------------------------------------------------------------
|
|
|
|
File base = new File( basedir );
|
|
|
|
String modelFileName = (String) MODELLO_MODEL_FILES.get( projectId );
|
|
|
|
File model = null;
|
|
if ( modelFileName != null && modelFileName.trim().length() > 0 )
|
|
{
|
|
model = new File( base, modelFileName );
|
|
}
|
|
|
|
if ( model != null && model.exists() )
|
|
{
|
|
System.out.println( "Model exists!" );
|
|
|
|
String modelVersion = (String) MODELLO_TARGET_VERSIONS.get( projectId );
|
|
if ( modelVersion == null || modelVersion.trim().length() < 1 )
|
|
{
|
|
System.out.println( "No model version configured. Using \'1.0.0\'..." );
|
|
modelVersion = "1.0.0";
|
|
}
|
|
|
|
File generatedSourcesDirectory = new File( basedir, GENERATED_SOURCES );
|
|
|
|
if ( !generatedSourcesDirectory.exists() )
|
|
{
|
|
generatedSourcesDirectory.mkdirs();
|
|
}
|
|
|
|
File generatedDocsDirectory = new File( basedir, GENERATED_DOCS );
|
|
|
|
if ( !generatedDocsDirectory.exists() )
|
|
{
|
|
generatedDocsDirectory.mkdirs();
|
|
}
|
|
|
|
System.out.println(
|
|
"Generating model bindings for version \'" + modelVersion + "\' in project: " + projectId );
|
|
|
|
generateSources( model.getAbsolutePath(), "java", generatedSources, modelVersion, "false", classLoader );
|
|
generateSources( model.getAbsolutePath(), "xpp3-reader", generatedSources, modelVersion, "false",
|
|
classLoader );
|
|
generateSources( model.getAbsolutePath(), "xpp3-writer", generatedSources, modelVersion, "false",
|
|
classLoader );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Standard compile
|
|
// ----------------------------------------------------------------------
|
|
|
|
System.out.println( "Compiling sources ..." );
|
|
|
|
if ( new File( generatedSources ).exists() )
|
|
{
|
|
compile( reader.getDependencies(), sources, classes, null, generatedSources, Dependency.SCOPE_COMPILE,
|
|
localRepository );
|
|
}
|
|
else
|
|
{
|
|
compile( reader.getDependencies(), sources, classes, null, null, Dependency.SCOPE_COMPILE,
|
|
localRepository );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Plugin descriptor generation
|
|
// ----------------------------------------------------------------------
|
|
|
|
if ( reader.getPackaging().equals( "maven-plugin" ) )
|
|
{
|
|
System.out.println( "Generating maven plugin descriptor ..." );
|
|
|
|
generatePluginDescriptor( sources, new File( classes, "META-INF/maven" ).getAbsolutePath(),
|
|
new File( basedir, "pom.xml" ).getAbsolutePath(), classLoader, localRepository );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Standard resources
|
|
// ----------------------------------------------------------------------
|
|
|
|
System.out.println( "Packaging resources ..." );
|
|
|
|
copyResources( resources, classes );
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Test compile
|
|
// ----------------------------------------------------------------------
|
|
|
|
System.out.println( "Compiling test sources ..." );
|
|
|
|
Collection testDependencies = new ArrayList( reader.getDependencies() );
|
|
|
|
compile( testDependencies, testSources, testClasses, classes, null, Dependency.SCOPE_TEST, localRepository );
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Test resources
|
|
// ----------------------------------------------------------------------
|
|
|
|
System.out.println( "Packaging test resources ..." );
|
|
|
|
copyResources( testResources, testClasses );
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Run tests
|
|
// ----------------------------------------------------------------------
|
|
|
|
runTests( basedir, classes, testClasses, reader, surefireDependencies, localRepository );
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Create JAR
|
|
// ----------------------------------------------------------------------
|
|
|
|
createJar( new File( basedir, "pom.xml" ), classes, buildDir, reader );
|
|
|
|
installPom( basedir, localRepository, reader );
|
|
|
|
install( basedir, localRepository, reader, reader.getPackaging() );
|
|
|
|
return reader;
|
|
}
|
|
|
|
private void generatePluginDescriptor( String sourceDirectory, String outputDirectory, String pom, ClassLoader cl,
|
|
Repository localRepository )
|
|
throws Exception
|
|
{
|
|
Class cls = cl.loadClass( "org.apache.maven.tools.plugin.pluggy.Main" );
|
|
|
|
Method m = cls.getMethod( "main", new Class[]{String[].class} );
|
|
|
|
// Can pluggy really cope with the layout?
|
|
String[] args = {"descriptor", sourceDirectory, outputDirectory, pom, localRepository.getBasedir()};
|
|
|
|
m.invoke( null, new Object[]{args} );
|
|
}
|
|
|
|
private void generateSources( String model, String mode, String dir, String modelVersion, String packageWithVersion,
|
|
ClassLoader modelloClassLoader )
|
|
throws Exception
|
|
{
|
|
Class c = modelloClassLoader.loadClass( "org.codehaus.modello.ModelloCli" );
|
|
|
|
Object generator = c.newInstance();
|
|
|
|
Method m = c.getMethod( "main", new Class[]{String[].class} );
|
|
|
|
String[] args = new String[]{model, mode, dir, modelVersion, packageWithVersion};
|
|
|
|
ClassLoader old = Thread.currentThread().getContextClassLoader();
|
|
|
|
Thread.currentThread().setContextClassLoader( modelloClassLoader );
|
|
|
|
m.invoke( generator, new Object[]{args} );
|
|
|
|
Thread.currentThread().setContextClassLoader( old );
|
|
}
|
|
|
|
private IsolatedClassLoader createClassloaderFromDependencies( Collection dependencies, ClassLoader parent,
|
|
Repository localRepository )
|
|
throws Exception
|
|
{
|
|
if ( online )
|
|
{
|
|
System.out.println( "Checking for dependencies ..." );
|
|
|
|
downloader.downloadDependencies( dependencies );
|
|
}
|
|
|
|
IsolatedClassLoader cl;
|
|
if ( parent == null )
|
|
{
|
|
cl = new IsolatedClassLoader();
|
|
}
|
|
else
|
|
{
|
|
cl = new IsolatedClassLoader( parent );
|
|
}
|
|
|
|
for ( Iterator i = dependencies.iterator(); i.hasNext(); )
|
|
{
|
|
Dependency dependency = (Dependency) i.next();
|
|
|
|
File f = localRepository.getArtifactFile( dependency );
|
|
if ( !f.exists() )
|
|
{
|
|
String msg = ( !online ? "; run again online" : "; there was a problem downloading it earlier" );
|
|
throw new FileNotFoundException( "Missing dependency: " + dependency + msg );
|
|
}
|
|
|
|
cl.addURL( f.toURL() );
|
|
}
|
|
|
|
return cl;
|
|
}
|
|
|
|
private void createJar( File pomFile, String classes, String buildDir, ModelReader reader )
|
|
throws Exception
|
|
{
|
|
JarMojo jarMojo = new JarMojo();
|
|
|
|
String artifactId = reader.getArtifactId();
|
|
|
|
String version = reader.getVersion();
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Create pom.properties file
|
|
// ----------------------------------------------------------------------
|
|
|
|
Properties p = new Properties();
|
|
|
|
p.setProperty( "groupId", reader.getGroupId() );
|
|
|
|
p.setProperty( "artifactId", reader.getArtifactId() );
|
|
|
|
p.setProperty( "version", reader.getVersion() );
|
|
|
|
File pomPropertiesDir = new File( new File( classes ),
|
|
"META-INF/maven/" + reader.getGroupId() + "/" + reader.getArtifactId() );
|
|
|
|
pomPropertiesDir.mkdirs();
|
|
|
|
File pomPropertiesFile = new File( pomPropertiesDir, "pom.properties" );
|
|
|
|
OutputStream os = new FileOutputStream( pomPropertiesFile );
|
|
|
|
p.store( os, "Generated by Maven" );
|
|
|
|
os.close(); // stream is flushed but not closed by Properties.store()
|
|
|
|
FileUtils.copyFile( pomFile, new File( pomPropertiesDir, "pom.xml" ) );
|
|
|
|
jarMojo.execute( new File( classes ), buildDir, artifactId + "-" + version );
|
|
}
|
|
|
|
private void installPomFile( Repository localRepository, File pomIn )
|
|
throws Exception
|
|
{
|
|
ModelReader reader = new ModelReader( downloader, false );
|
|
|
|
reader.parse( pomIn );
|
|
|
|
installPomFile( reader, localRepository, pomIn );
|
|
}
|
|
|
|
private void installPom( String basedir, Repository localRepository, ModelReader reader )
|
|
throws Exception
|
|
{
|
|
installPomFile( reader, localRepository, new File( basedir, "pom.xml" ) );
|
|
}
|
|
|
|
private void installPomFile( ModelReader reader, Repository localRepository, File source )
|
|
throws IOException
|
|
{
|
|
String artifactId = reader.getArtifactId();
|
|
|
|
String version = reader.getVersion();
|
|
|
|
String groupId = reader.getGroupId();
|
|
|
|
File pom = localRepository.getMetadataFile( groupId, artifactId, version, reader.getPackaging(),
|
|
artifactId + "-" + version + ".pom" );
|
|
|
|
System.out.println( "Installing POM: " + pom );
|
|
|
|
FileUtils.copyFile( source, pom );
|
|
}
|
|
|
|
private void install( String basedir, Repository localRepository, ModelReader reader, String type )
|
|
throws Exception
|
|
{
|
|
String artifactId = reader.getArtifactId();
|
|
|
|
String version = reader.getVersion();
|
|
|
|
String groupId = reader.getGroupId();
|
|
|
|
String finalName = artifactId + "-" + version;
|
|
|
|
File file = localRepository.getArtifactFile( groupId, artifactId, version, type );
|
|
|
|
System.out.println( "Installing: " + file );
|
|
|
|
FileUtils.copyFile( new File( basedir, BUILD_DIR + "/" + finalName + ".jar" ), file );
|
|
|
|
RepositoryMetadata metadata = new RepositoryMetadata();
|
|
metadata.setReleaseVersion( version );
|
|
file = localRepository.getMetadataFile( groupId, artifactId, null, type, "maven-metadata-local.xml" );
|
|
metadata.write( file );
|
|
|
|
metadata = new RepositoryMetadata();
|
|
metadata.setLocalCopy( true );
|
|
file = localRepository.getMetadataFile( groupId, artifactId, version, type, "maven-metadata-local.xml" );
|
|
metadata.write( file );
|
|
}
|
|
|
|
private void runTests( String basedir, String classes, String testClasses, ModelReader reader,
|
|
List surefireDependencies, Repository localRepository )
|
|
throws Exception
|
|
{
|
|
SurefirePlugin testRunner = new SurefirePlugin();
|
|
|
|
List includes;
|
|
|
|
List excludes;
|
|
|
|
includes = new ArrayList();
|
|
|
|
includes.add( "**/*Test.java" );
|
|
includes.add( "**/*TestCase.java" );
|
|
|
|
excludes = new ArrayList();
|
|
|
|
excludes.add( "**/Abstract*Test.java" );
|
|
excludes.add( "**/Abstract*TestCase.java" );
|
|
|
|
String reportsDir = new File( basedir, "target/surefire-reports" ).getAbsolutePath();
|
|
|
|
List depList = new ArrayList( reader.getDependencies() );
|
|
depList.addAll( surefireDependencies );
|
|
|
|
List classpath = classpath( depList, null, Dependency.SCOPE_TEST, localRepository );
|
|
classpath.add( classes );
|
|
classpath.add( testClasses );
|
|
|
|
boolean success = testRunner.execute( basedir, includes, excludes, classpath, reportsDir );
|
|
|
|
if ( !success )
|
|
{
|
|
throw new Exception( "Tests error" );
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Compile
|
|
// ----------------------------------------------------------------------
|
|
|
|
private List classpath( Collection dependencies, String extraClasspath, String scope, Repository localRepository )
|
|
{
|
|
List classpath = new ArrayList( dependencies.size() + 1 );
|
|
|
|
for ( Iterator i = dependencies.iterator(); i.hasNext(); )
|
|
{
|
|
Dependency d = (Dependency) i.next();
|
|
|
|
String element = localRepository.getArtifactFile( d ).getAbsolutePath();
|
|
|
|
if ( Dependency.SCOPE_COMPILE.equals( scope ) )
|
|
{
|
|
if ( d.getScope().equals( Dependency.SCOPE_COMPILE ) )
|
|
{
|
|
classpath.add( element );
|
|
}
|
|
}
|
|
else if ( Dependency.SCOPE_RUNTIME.equals( scope ) )
|
|
{
|
|
if ( d.getScope().equals( Dependency.SCOPE_COMPILE ) ||
|
|
d.getScope().equals( Dependency.SCOPE_RUNTIME ) )
|
|
{
|
|
classpath.add( element );
|
|
}
|
|
}
|
|
else if ( Dependency.SCOPE_TEST.equals( scope ) )
|
|
{
|
|
classpath.add( element );
|
|
}
|
|
}
|
|
|
|
if ( extraClasspath != null )
|
|
{
|
|
classpath.add( extraClasspath );
|
|
}
|
|
|
|
return classpath;
|
|
}
|
|
|
|
private void compile( Collection dependencies, String sourceDirectory, String outputDirectory,
|
|
String extraClasspath, String generatedSources, String scope, Repository localRepository )
|
|
throws Exception
|
|
{
|
|
JavacCompiler compiler = new JavacCompiler();
|
|
|
|
String[] sourceDirectories = null;
|
|
|
|
if ( generatedSources != null )
|
|
{
|
|
// We might only have generated sources
|
|
|
|
if ( new File( sourceDirectory ).exists() )
|
|
{
|
|
sourceDirectories = new String[]{sourceDirectory, generatedSources};
|
|
}
|
|
else
|
|
{
|
|
sourceDirectories = new String[]{generatedSources};
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( new File( sourceDirectory ).exists() )
|
|
{
|
|
sourceDirectories = new String[]{sourceDirectory};
|
|
}
|
|
}
|
|
|
|
if ( sourceDirectories != null )
|
|
{
|
|
CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
|
|
compilerConfiguration.setOutputLocation( outputDirectory );
|
|
List classpathEntries = classpath( dependencies, extraClasspath, scope, localRepository );
|
|
compilerConfiguration.setNoWarn( true );
|
|
compilerConfiguration.setClasspathEntries( classpathEntries );
|
|
compilerConfiguration.setSourceLocations( Arrays.asList( sourceDirectories ) );
|
|
|
|
/* Compile with debugging info */
|
|
String debugAsString = System.getProperty( "maven.compiler.debug", "true" );
|
|
|
|
if ( !Boolean.valueOf( debugAsString ).booleanValue() )
|
|
{
|
|
compilerConfiguration.setDebug( false );
|
|
}
|
|
else
|
|
{
|
|
compilerConfiguration.setDebug( true );
|
|
}
|
|
|
|
List messages = compiler.compile( compilerConfiguration );
|
|
|
|
for ( Iterator i = messages.iterator(); i.hasNext(); )
|
|
{
|
|
System.out.println( i.next() );
|
|
}
|
|
|
|
if ( messages.size() > 0 )
|
|
{
|
|
throw new Exception( "Compilation error." );
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// model.Resource copying
|
|
// ----------------------------------------------------------------------
|
|
|
|
private void copyResources( String sourceDirectory, String destinationDirectory )
|
|
throws Exception
|
|
{
|
|
File sd = new File( sourceDirectory );
|
|
|
|
if ( !sd.exists() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
List files = FileUtils.getFiles( sd, "**/**", "**/CVS/**,**/.svn/**", false );
|
|
|
|
for ( Iterator i = files.iterator(); i.hasNext(); )
|
|
{
|
|
File f = (File) i.next();
|
|
|
|
File source = new File( sourceDirectory, f.getPath() );
|
|
|
|
File dest = new File( destinationDirectory, f.getPath() );
|
|
|
|
if ( !dest.getParentFile().exists() )
|
|
{
|
|
dest.getParentFile().mkdirs();
|
|
}
|
|
|
|
FileUtils.copyFile( source, dest );
|
|
}
|
|
}
|
|
|
|
class SettingsReader
|
|
extends AbstractReader
|
|
{
|
|
private List mirrors = new ArrayList();
|
|
|
|
private List proxies = new ArrayList();
|
|
|
|
private Proxy currentProxy = null;
|
|
|
|
private StringBuffer currentBody = new StringBuffer();
|
|
|
|
private Proxy activeProxy = null;
|
|
|
|
private Mirror currentMirror;
|
|
|
|
private String localRepository;
|
|
|
|
public String getLocalRepository()
|
|
{
|
|
return localRepository;
|
|
}
|
|
|
|
public Proxy getActiveProxy()
|
|
{
|
|
return activeProxy;
|
|
}
|
|
|
|
public void characters( char[] ch, int start, int length )
|
|
throws SAXException
|
|
{
|
|
currentBody.append( ch, start, length );
|
|
}
|
|
|
|
public void endElement( String uri, String localName, String rawName )
|
|
throws SAXException
|
|
{
|
|
if ( "localRepository".equals( rawName ) )
|
|
{
|
|
if ( notEmpty( currentBody.toString() ) )
|
|
{
|
|
localRepository = currentBody.toString().trim();
|
|
}
|
|
else
|
|
{
|
|
throw new SAXException(
|
|
"Invalid profile entry. Missing one or more " + "fields: {localRepository}." );
|
|
}
|
|
}
|
|
else if ( "proxy".equals( rawName ) )
|
|
{
|
|
if ( notEmpty( currentProxy.getHost() ) && notEmpty( currentProxy.getPort() ) )
|
|
{
|
|
proxies.add( currentProxy );
|
|
currentProxy = null;
|
|
}
|
|
else
|
|
{
|
|
throw new SAXException( "Invalid proxy entry. Missing one or more fields: {host, port}." );
|
|
}
|
|
}
|
|
else if ( currentProxy != null )
|
|
{
|
|
if ( "active".equals( rawName ) )
|
|
{
|
|
currentProxy.setActive( Boolean.valueOf( currentBody.toString().trim() ).booleanValue() );
|
|
}
|
|
else if ( "host".equals( rawName ) )
|
|
{
|
|
currentProxy.setHost( currentBody.toString().trim() );
|
|
}
|
|
else if ( "port".equals( rawName ) )
|
|
{
|
|
currentProxy.setPort( currentBody.toString().trim() );
|
|
}
|
|
else if ( "username".equals( rawName ) )
|
|
{
|
|
currentProxy.setUserName( currentBody.toString().trim() );
|
|
}
|
|
else if ( "password".equals( rawName ) )
|
|
{
|
|
currentProxy.setPassword( currentBody.toString().trim() );
|
|
}
|
|
else if ( "protocol".equals( rawName ) )
|
|
{
|
|
}
|
|
else if ( "nonProxyHosts".equals( rawName ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
throw new SAXException( "Illegal element inside proxy: \'" + rawName + "\'" );
|
|
}
|
|
}
|
|
else if ( "mirror".equals( rawName ) )
|
|
{
|
|
if ( notEmpty( currentMirror.getId() ) && notEmpty( currentMirror.getMirrorOf() ) &&
|
|
notEmpty( currentMirror.getUrl() ) )
|
|
{
|
|
mirrors.add( currentMirror );
|
|
currentMirror = null;
|
|
}
|
|
else
|
|
{
|
|
throw new SAXException( "Invalid mirror entry. Missing one or more fields: {id, mirrorOf, url}." );
|
|
}
|
|
}
|
|
else if ( currentMirror != null )
|
|
{
|
|
if ( "id".equals( rawName ) )
|
|
{
|
|
currentMirror.setId( currentBody.toString().trim() );
|
|
}
|
|
else if ( "mirrorOf".equals( rawName ) )
|
|
{
|
|
currentMirror.setMirrorOf( currentBody.toString().trim() );
|
|
}
|
|
else if ( "url".equals( rawName ) )
|
|
{
|
|
currentMirror.setUrl( currentBody.toString().trim() );
|
|
}
|
|
else if ( "name".equals( rawName ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
throw new SAXException( "Illegal element inside proxy: \'" + rawName + "\'" );
|
|
}
|
|
}
|
|
else if ( "settings".equals( rawName ) )
|
|
{
|
|
if ( proxies.size() != 0 )
|
|
{
|
|
for ( Iterator it = proxies.iterator(); it.hasNext(); )
|
|
{
|
|
Proxy proxy = (Proxy) it.next();
|
|
if ( proxy.isActive() )
|
|
{
|
|
activeProxy = proxy;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
currentBody = new StringBuffer();
|
|
}
|
|
|
|
private boolean notEmpty( String test )
|
|
{
|
|
return test != null && test.trim().length() > 0;
|
|
}
|
|
|
|
public void startElement( String uri, String localName, String rawName, Attributes attributes )
|
|
throws SAXException
|
|
{
|
|
if ( "proxy".equals( rawName ) )
|
|
{
|
|
currentProxy = new Proxy();
|
|
}
|
|
else if ( "mirror".equals( rawName ) )
|
|
{
|
|
currentMirror = new Mirror();
|
|
}
|
|
}
|
|
|
|
public void reset()
|
|
{
|
|
this.currentBody = null;
|
|
this.activeProxy = null;
|
|
this.currentMirror = null;
|
|
this.localRepository = null;
|
|
this.proxies.clear();
|
|
this.mirrors.clear();
|
|
}
|
|
|
|
public List getMirrors()
|
|
{
|
|
return mirrors;
|
|
}
|
|
}
|
|
|
|
public static class Proxy
|
|
{
|
|
private boolean active;
|
|
|
|
private String host;
|
|
|
|
private String port;
|
|
|
|
private String userName;
|
|
|
|
private String password;
|
|
|
|
public boolean isActive()
|
|
{
|
|
return active;
|
|
}
|
|
|
|
public void setActive( boolean active )
|
|
{
|
|
this.active = active;
|
|
}
|
|
|
|
public void setHost( String host )
|
|
{
|
|
this.host = host;
|
|
}
|
|
|
|
public String getHost()
|
|
{
|
|
return host;
|
|
}
|
|
|
|
public void setPort( String port )
|
|
{
|
|
this.port = port;
|
|
}
|
|
|
|
public String getPort()
|
|
{
|
|
return port;
|
|
}
|
|
|
|
public void setUserName( String userName )
|
|
{
|
|
this.userName = userName;
|
|
}
|
|
|
|
public String getUserName()
|
|
{
|
|
return userName;
|
|
}
|
|
|
|
public void setPassword( String password )
|
|
{
|
|
this.password = password;
|
|
}
|
|
|
|
public String getPassword()
|
|
{
|
|
return password;
|
|
}
|
|
}
|
|
|
|
public static class Mirror
|
|
{
|
|
private String id;
|
|
|
|
private String mirrorOf;
|
|
|
|
private String url;
|
|
|
|
public String getId()
|
|
{
|
|
return id;
|
|
}
|
|
|
|
public void setId( String id )
|
|
{
|
|
this.id = id;
|
|
}
|
|
|
|
public void setMirrorOf( String mirrorOf )
|
|
{
|
|
this.mirrorOf = mirrorOf;
|
|
}
|
|
|
|
public void setUrl( String url )
|
|
{
|
|
this.url = url;
|
|
}
|
|
|
|
public String getMirrorOf()
|
|
{
|
|
return mirrorOf;
|
|
}
|
|
|
|
public String getUrl()
|
|
{
|
|
return url;
|
|
}
|
|
}
|
|
}
|