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);
if (unit != null)
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)
{
{
thread.setContextClassLoader(classLoader);
build((MetadataImplementor)metadataBuilder.build(), options, target);
+ if (handler.getExceptions().size() > 0)
+ {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Hibernate failed:");
+ for (Exception e : handler.getExceptions())
+ {
+ builder.append("\n * ");
+ builder.append(e.getMessage());
+ AbstractSchemaMojo.printStrackTrace(builder, e);
+ builder.append("\n");
+ }
+ String error = builder.toString();
+ getLog().error(error);
+ throw new MojoFailureException(error);
+ }
}
finally
{
thread.setContextClassLoader(contextClassLoader);
- for (Exception e : handler.getExceptions())
- getLog().error(e.getMessage());
/** Track, the content of the generated script */
checkOutputFile(output, tracker);
}
}
}
- 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);
* switched to "true", the genearation fo the schema should be forced!
*/
if (tracker.check(EXECUTE, execute.toString()) && execute)
+ {
+ getLog().info(
+ "hibernate.schema.execute was switched on: " +
+ "forcing generation/execution of SQL"
+ );
tracker.touch();
+ }
+ configure(properties, execute, EXECUTE);
/**
* Configure the generation of the SQL.
configure(properties, createNamespaces, HBM2DLL_CREATE_NAMESPACES);
configure(properties, implicitNamingStrategy, IMPLICIT_NAMING_STRATEGY);
configure(properties, physicalNamingStrategy, PHYSICAL_NAMING_STRATEGY);
- tracker.track(OUTPUTDIRECTORY, outputDirectory); // << not reflected in hibernate configuration!
- tracker.track(SCAN_DEPENDENCIES, scanDependencies); // << not reflected in hibernate configuration!
- tracker.track(SCAN_TESTCLASSES, scanTestClasses.toString()); // << not reflected in hibernate configuration!
- tracker.track(TEST_OUTPUTDIRECTORY, testOutputDirectory); // << not reflected in hibernate configuration!
+ configure(properties, outputDirectory, OUTPUTDIRECTORY);
+ configure(properties, scanDependencies, SCAN_DEPENDENCIES);
+ configure(properties, scanTestClasses, SCAN_TESTCLASSES);
+ configure(properties, testOutputDirectory, TEST_OUTPUTDIRECTORY);
/**
* Special treatment for the configuration-value "show": a change of its
throw new MojoFailureException("Hibernate configuration is missing!");
}
- getLog().info("Gathered hibernate-configuration (turn on debugging for details):");
+ getLog().info("Gathered configuration:");
for (Entry<Object,Object> entry : properties.entrySet())
getLog().info(" " + entry.getKey() + " = " + entry.getValue());
}
if (value != null)
{
if (properties.containsKey(key))
- getLog().info(
- "Overwriting property " + key + "=\"" +
- properties.getProperty(key) +
- "\" with value \"" + value + "\""
- );
+ {
+ if (!properties.getProperty(key).equals(value))
+ {
+ getLog().info(
+ "Overwriting property " + key + "=\"" +
+ properties.getProperty(key) +
+ "\" with value \"" + value + "\""
+ );
+ properties.setProperty(key, value);
+ }
+ }
else
+ {
getLog().debug("Using value \"" + value + "\" for property " + key);
- properties.setProperty(key, value);
+ properties.setProperty(key, value);
+ }
}
}
// 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);
}
{
try
{
- File dir = new File(outputDirectory);
+ 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());
}
}
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();
+ }
+ }
}