import javax.persistence.Embeddable;
import javax.persistence.Entity;
import javax.persistence.MappedSuperclass;
-import javax.persistence.spi.PersistenceUnitTransactionType;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.AbstractMojo;
Properties properties = new Properties();
ConfigLoader configLoader = new ConfigLoader(bootstrapServiceRegitry);
- /** Loading and merging configuration */
+ /** Loading configuration */
properties.putAll(loadProperties(configLoader));
LoadedConfig config = loadConfig(configLoader);
if (config != null)
properties.putAll(config.getConfigurationValues());
+
+ /** Add the remaining class-path-elements */
+ addDirectDependenciesClassPath(classLoader);
+
+ /** Loading and merging configuration from persistence-unit(s) */
ParsedPersistenceXmlDescriptor unit =
- loadPersistenceUnit(classLoaderService, properties);
+ loadPersistenceUnit(classLoader, properties);
if (unit != null)
properties.putAll(unit.getProperties());
final MetadataSources sources = new MetadataSources(serviceRegistry);
/** Add the remaining class-path-elements */
- completeClassPath(classLoader);
+ addAllDependenciesToClassPath(classLoader);
/** Apply mappings from hibernate-configuration, if present */
if (config != null)
if (scanClasses == null)
scanClasses = true;
Set<URL> urls = new HashSet<URL>();
+ getLog().debug("Compiling the dependencies, that are scanned for annotated classes");
if (scanClasses)
addRoot(urls, outputDirectory);
if (scanTestClasses)
/** Follow configuration in persisten unit */
if (scanClasses == null)
scanClasses = !unit.isExcludeUnlistedClasses();
+ getLog().debug("Compiling the dependencies, that are scanned for annotated classes");
+
Set<URL> urls = new HashSet<URL>();
if (scanClasses)
{
+ getLog().debug("Only dependencies relative to persistent-unit " + unit.getName() + " are scanned!");
/**
* Scan the root of the persiten unit and configured jars for
* annotated classes
*/
+ getLog().debug(" - adding " + unit.getPersistenceUnitRootUrl());
urls.add(unit.getPersistenceUnitRootUrl());
for (URL url : unit.getJarFileUrls())
+ {
+ getLog().debug(" - adding " + url);
urls.add(url);
+ }
+ if (scanTestClasses)
+ addRoot(urls, testOutputDirectory);
}
- if (scanTestClasses)
- addRoot(urls, testOutputDirectory);
+ else
+ getLog().debug("Scanning of unlisted classes is prohibited in persistent-unit " + unit.getName());
classes = scanUrls(urls);
for (String className : unit.getManagedClassNames())
classes.add(className);
* Add mappings from files, that are explicitly configured in the
* persistence unit
*/
+ getLog().info("Adding mappings from persistence-unit " + unit.getName());
for (String mapping : unit.getMappingFileNames())
{
- getLog().info("Adding explicitly configured mapping from " + mapping);
+ getLog().info(" - adding " + mapping);
is = classLoader.getResourceAsStream(mapping);
if (is != null)
{
{
builder.append("\n * ");
builder.append(e.getMessage());
+ AbstractSchemaMojo.printStrackTrace(builder, e);
+ builder.append("\n");
}
String error = builder.toString();
getLog().error(error);
}
}
- private void completeClassPath(MutableClassLoader classLoader)
+ private void addDirectDependenciesClassPath(MutableClassLoader classLoader)
throws
MojoExecutionException
{
try
{
- getLog().debug("Completing class-paths of the ClassLoader for project-dependencies...");
- List<String> classpathFiles = project.getCompileClasspathElements();
+ getLog().debug("Adding all direct project-dependencies to the ClassLoader...");
+ LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
+ addDependencies(urls);
if (scanTestClasses)
- classpathFiles.addAll(project.getTestClasspathElements());
+ addRoot(urls, testOutputDirectory);
+ classLoader.add(urls);
+ }
+ catch (Exception e)
+ {
+ getLog().error("Error while creating ClassLoader!", e);
+ throw new MojoExecutionException(e.getMessage());
+ }
+ }
+
+ private void addAllDependenciesToClassPath(MutableClassLoader classLoader)
+ throws
+ MojoExecutionException
+ {
+ try
+ {
+ getLog().debug("Adding all project-dependencies to the ClassLoader...");
+ List<String> classpathFiles = project.getCompileClasspathElements();
+ classpathFiles.addAll(project.getTestClasspathElements());
LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
for (String pathElement : classpathFiles)
{
- getLog().debug("Dependency: " + pathElement);
+ getLog().debug(" - adding " + pathElement);
urls.add(new File(pathElement).toURI().toURL());
}
classLoader.add(urls);
// TODO: add support to read all mappings under a directory
throw new MojoFailureException(file.getAbsolutePath() + " is a directory");
if (tracker.track(filename, new FileInputStream(file)))
- getLog().debug("Found new or modified mapping-file: " + filename);
+ getLog().debug(" - found new or modified mapping-file: " + filename);
else
- getLog().debug("Mapping-file unchanged: " + filename);
+ getLog().debug(" - mapping-file unchanged: " + filename);
sources.addFile(file);
}
File dir = new File(path);
if (dir.exists())
{
- getLog().info("Adding " + dir.getAbsolutePath() + " to the list of roots to scan...");
+ getLog().info(" - adding " + dir.getAbsolutePath());
urls.add(dir.toURI().toURL());
}
+ else
+ getLog().warn(
+ "The directory cannot be scanned for annotated classes, " +
+ "because it does not exist: " +
+ dir.getAbsolutePath()
+ );
}
catch (MalformedURLException e)
{
Matcher matcher = SPLIT.matcher(scanDependencies);
while (matcher.find())
{
- getLog().info("Adding dependencies from scope " + matcher.group() + " to the list of roots to scan");
+ getLog().debug("Adding dependencies from scope " + matcher.group() + " to the list of roots to scan");
for (Artifact artifact : project.getDependencyArtifacts())
{
if (!artifact.getScope().equalsIgnoreCase(matcher.group()))
getLog().warn("Cannot add dependency " + artifact.getId() + ": no JAR-file available!");
continue;
}
- getLog().info("Adding dependencies from scope " + artifact.getId() + " to the list of roots to scan");
+ getLog().debug(" - adding " + artifact.getId());
urls.add(artifact.getFile().toURI().toURL());
}
}
}
private ParsedPersistenceXmlDescriptor loadPersistenceUnit(
- ClassLoaderService classLoaderService,
+ ClassLoader classLoader,
Properties properties
)
throws
MojoFailureException
{
- PersistenceXmlParser parser =
- new PersistenceXmlParser(
- classLoaderService,
- PersistenceUnitTransactionType.RESOURCE_LOCAL
- );
+ Map<String, ? extends Object> settings =
+ Collections.singletonMap(
+ AvailableSettings.CLASSLOADERS,
+ Collections.singletonList(classLoader)
+ );
+ // Find all available persistent unit descriptors
+ List<ParsedPersistenceXmlDescriptor> descriptors =
+ PersistenceXmlParser.locatePersistenceUnits(settings);
+ // Find all persistent units in the located descriptors
Map<String, ParsedPersistenceXmlDescriptor> units =
- parser.doResolve(properties);
+ new HashMap<String, ParsedPersistenceXmlDescriptor>();
+ for (ParsedPersistenceXmlDescriptor descriptor : descriptors)
+ {
+ String unit = descriptor.getName();
+ if (units.containsKey(unit))
+ getLog().warn(
+ "Persistence unit " + unit +
+ " from " + descriptor.getPersistenceUnitRootUrl() +
+ " overwrites unit with the same name from " +
+ units.get(unit).getPersistenceUnitRootUrl()
+ );
+ units.put(unit, descriptor);
+ }
if (persistenceUnit == null)
{
throw new MojoFailureException("Could not find persistence-unit " + persistenceUnit);
}
+
+
+ public static void printStrackTrace(StringBuilder builder, Throwable t)
+ {
+ while (t != null)
+ {
+ builder.append("\n\tCause: ");
+ builder.append(t.getMessage() == null ? "" : t.getMessage().replaceAll("\\s+", " "));
+ for (StackTraceElement trace : t.getStackTrace())
+ {
+ builder.append("\n\t");
+ builder.append(trace.getClassName());
+ builder.append(".");
+ builder.append(trace.getMethodName());
+ builder.append("():");
+ builder.append(trace.getLineNumber());
+ }
+ t = t.getCause();
+ }
+ }
}
projects / hibernate4-maven-plugin / blobdiff