/*
* 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.
*/
package org.apache.openjpa.tools.maven;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.project.MavenProject;
import org.apache.openjpa.lib.util.Options;
import org.codehaus.plexus.util.FileUtils;
/**
* Base class for OpenJPA maven tasks.
*
* @version $Id$
*/
public abstract class AbstractOpenJpaMojo extends AbstractMojo
{
/**
* The working directory for putting persistence.xml and
* other stuff into if we need to.
*/
@Parameter(property="openjpa.workdir", defaultValue="${project.build.directory}/openjpa-work", required=true)
protected File workDir;
/**
* Location where <code>persistence-enabled</code> classes are located.
*/
@Parameter(property="openjpa.classes", defaultValue="${project.build.outputDirectory}", required=true)
protected File classes;
/**
* Comma separated list of includes to scan searchDir to pass to the jobs.
* This may be used to restrict the OpenJPA tasks to e.g. a single package which
* contains all the entities.
*/
@Parameter(defaultValue="**/*.class")
private String includes;
/**
* Comma separated list of excludes to scan searchDir to pass to the jobs.
* This option may be used to stop OpenJPA tasks from scanning non-JPA classes
* (which usually leads to warnings such as "Type xxx has no metadata")
*/
@Parameter(defaultValue="")
private String excludes;
/**
* Additional properties passed to the OpenJPA tools.
*/
@Parameter
private Properties toolProperties;
/**
* Used if a non-default file location for the persistence.xml should be used
* If not specified, the default one in META-INF/persistence.xml will be used.
* Since openjpa-2.3.0 this can also be a resource location. In prior releases
* it was only possible to specify a file location.
*/
@Parameter
private String persistenceXmlFile;
/**
* An optional PersistenceUnit name.
* If not specified then OpenJPA will run against 'all anchors'.
* Means it will use all persistenceunits of all persistence.xml files it finds.
*/
@Parameter(defaultValue="${openjpa.persistenceUnitName}")
private String persistenceUnitName;
/**
* <p>This setting can be used to override any openjpa.ConnectionDriverName set in the
* persistence.xml. It can also be used if the persistence.xml contains no connection
* information at all.<P>
*
* Sample:
* <pre>
* <connectionDriverName>com.mchange.v2.c3p0.ComboPooledDataSource</connectionDriverName>
* </pre>
*
* This is most times used in conjunction with {@link #connectionProperties}.
*/
@Parameter
private String connectionDriverName;
/** the string used for passing information about the connectionDriverName */
protected static final String OPTION_CONNECTION_DRIVER_NAME = "ConnectionDriverName";
/**
* <p>Used to define the credentials or any other connection properties.</p>
*
* Sample:
* <pre>
* <connectionProperties>
* driverClass=com.mysql.jdbc.Driver,
* jdbcUrl=jdbc:mysql://localhost/mydatabase,
* user=root,
* password=,
* minPoolSize=5,
* acquireRetryAttempts=3,
* maxPoolSize=20
* </connectionProperties>
* </pre>
*
* This is most times used in conjunction with {@link #connectionDriverName}.
*/
@Parameter
private String connectionProperties;
/** the string used for passing information about the connectionProperties */
protected static final String OPTION_CONNECTION_PROPERTIES = "ConnectionProperties";
/**
* List of all class path elements that will be searched for the
* <code>persistence-enabled</code> classes and resources expected by
* PCEnhancer.
*/
@Parameter(defaultValue="${project.compileClasspathElements}", required=true, readonly=true)
protected List<String> compileClasspathElements;
/**
* Setting this parameter to <code>true</code> will force
* the execution of this mojo, even if it would get skipped usually.
*/
@Parameter(property="forceOpenJpaExecution", defaultValue="false", required=true)
private boolean forceMojoExecution;
/**
* The Maven Project Object
*/
@Parameter(defaultValue="${project}", required=true, readonly=true)
protected MavenProject project;
/** the properties option is used for passing information about the persistence.xml file location */
protected static final String OPTION_PROPERTIES_FILE = "propertiesFile";
/**
* The properties option is used for passing information about the persistence.xml
* classpath resource and the default unit
*/
protected static final String OPTION_PROPERTIES = "properties";
/**
* When <code>true</code>, skip the execution.
* @since 1.0
*/
@Parameter(defaultValue="false")
private boolean skip;
/**
* default ct
*/
public AbstractOpenJpaMojo()
{
super();
}
/**
* The File where the class files of the entities to enhance reside
* @return normaly the entity classes are located in target/classes
*/
protected File getEntityClasses()
{
return classes;
}
/**
* This function retrieves the injected classpath elements for the current mojo.
* @return List of classpath elements for the compile phase
*/
protected List<String> getClasspathElements()
{
return compileClasspathElements;
}
/**
* Get the options for the various OpenJPA tools.
* @return populated Options
*/
protected abstract Options getOptions() throws MojoExecutionException;
/**
* <p>Determine if the mojo execution should get skipped.</p>
* This is the case if:
* <ul>
* <li>{@link #skip} is <code>true</code></li>
* <li>if the mojo gets executed on a project with packaging type 'pom' and
* {@link #forceMojoExecution} is <code>false</code></li>
* </ul>
*
* @return <code>true</code> if the mojo execution should be skipped.
*/
protected boolean skipMojo()
{
if ( skip )
{
getLog().info( "Skip sql execution" );
return true;
}
if ( !forceMojoExecution && project != null && "pom".equals( project.getPackaging() ) )
{
getLog().info( "Skipping sql execution for project with packaging type 'pom'" );
return true;
}
return false;
}
/**
* This function will usually get called by {@link #getOptions()}
* @return the Options filled with the initial values
*/
protected Options createOptions() throws MojoExecutionException
{
Options opts = new Options();
if ( toolProperties != null )
{
opts.putAll( toolProperties );
}
String persistenceXmlResource = "META-INF/persistence.xml";
if ( persistenceXmlFile != null && persistenceXmlFile.length() > 0)
{
fixPersistenceXmlIfNeeded(Thread.currentThread().getContextClassLoader());
opts.put( OPTION_PROPERTIES_FILE, persistenceXmlFile );
getLog().debug("using special persistence XML file: " + persistenceXmlFile);
persistenceXmlResource = persistenceXmlFile;
}
if (persistenceUnitName != null && persistenceUnitName.length() > 0) {
opts.put(OPTION_PROPERTIES, persistenceXmlResource + "#" + persistenceUnitName);
}
else if (!new File(classes, "META-INF/persistence.xml").exists())
{ // use default but try from classpath
persistenceXmlFile = "META-INF/persistence.xml";
if (!fixPersistenceXmlIfNeeded(Thread.currentThread().getContextClassLoader())) {
persistenceXmlFile = null;
} else {
opts.put( OPTION_PROPERTIES_FILE, persistenceXmlFile );
}
}
if ( connectionDriverName != null )
{
opts.put( OPTION_CONNECTION_DRIVER_NAME, connectionDriverName );
}
if ( connectionProperties != null )
{
opts.put( OPTION_CONNECTION_PROPERTIES, connectionProperties );
}
return opts;
}
/**
*
*
* @param loader
* @throws MojoExecutionException
*/
private boolean fixPersistenceXmlIfNeeded(final ClassLoader loader) throws MojoExecutionException
{
return !new File(persistenceXmlFile).exists() &&
(findPersistenceXmlFromLoader(loader)
|| findPersistenceXmlInArtifacts(project.getCompileArtifacts())
|| findPersistenceXmlInArtifacts(project.getRuntimeArtifacts()));
}
private boolean findPersistenceXmlFromLoader(final ClassLoader loader) throws MojoExecutionException {
final URL url = loader.getResource(persistenceXmlFile);
if (url != null) // copy file to be sure to set persistenceXmlFile to a file
{
final File tmpPersistenceXml = new File(workDir,
"persistence" + System.currentTimeMillis() + ".xml");
if (!tmpPersistenceXml.getParentFile().exists() && !tmpPersistenceXml.getParentFile().mkdirs())
{
throw new MojoExecutionException("Can't create "
+ tmpPersistenceXml.getParentFile().getAbsolutePath());
}
try
{
FileUtils.copyURLToFile(url, tmpPersistenceXml);
}
catch (final IOException e)
{
throw new MojoExecutionException(e.getMessage(), e);
}
persistenceXmlFile = tmpPersistenceXml.getAbsolutePath();
return true;
}
return false;
}
private boolean findPersistenceXmlInArtifacts(final List<Artifact> artifacts) throws MojoExecutionException {
for (final Artifact artifact : artifacts) {
final File file = artifact.getFile();
if (file != null && file.exists())
{
try // find the persistence.xml using a fake classloader to not need to play with URLs
{
if (findPersistenceXmlFromLoader(new URLClassLoader(new URL[] { file.toURI().toURL() },
ClassLoader.getSystemClassLoader())))
{
return true;
}
}
catch (final MalformedURLException e)
{
// no-op
}
}
}
return false;
}
/**
* This will prepare the current ClassLoader and add all jars and local
* classpaths (e.g. target/classes) needed by the OpenJPA task.
*
* @throws MojoExecutionException on any error inside the mojo
*/
protected void extendRealmClasspath()
throws MojoExecutionException
{
List<URL> urls = new ArrayList<URL>();
for(String fileName: getClasspathElements()) {
File pathElem = new File(fileName);
try
{
URL url = pathElem.toURI().toURL();
urls.add( url );
getLog().debug( "Added classpathElement URL " + url );
}
catch ( MalformedURLException e )
{
throw new MojoExecutionException( "Error in adding the classpath " + pathElem, e );
}
}
ClassLoader jpaRealm =
new URLClassLoader( (URL[]) urls.toArray( new URL[urls.size()] ), getClass().getClassLoader() );
// set the new ClassLoader as default for this Thread
Thread.currentThread().setContextClassLoader( jpaRealm );
}
/**
* Locates and returns a list of class files found under specified class
* directory.
*
* @return list of class files.
* @throws MojoExecutionException if there was an error scanning class file
* resources.
*/
protected List<File> findEntityClassFiles() throws MojoExecutionException
{
List<File> files = new ArrayList<File>();
try
{
files = (List<File>) FileUtils.getFiles( getEntityClasses(), includes, excludes );
}
catch ( IOException e )
{
throw new MojoExecutionException( "Error while scanning for '" + includes + "' in " + "'"
+ getEntityClasses().getAbsolutePath() + "'.", e );
}
return files;
}
/**
* @param files List of files
* @return the paths of the given files as String[]
*/
protected String[] getFilePaths( List<File> files )
{
String[] args = new String[ files.size() ];
for ( int i = 0; i < files.size(); i++ )
{
File file = files.get( i );
args[ i ] = file.getAbsolutePath();
}
return args;
}
}