juplo.de Git - hibernate4-maven-plugin/blob - plugins/hibernate/AbstractSchemaMojo.java

   1 package de.juplo.plugins.hibernate;
   2
   3
   4 import com.pyx4j.log4j.MavenLogAppender;
   5 import java.io.File;
   6 import java.io.FileInputStream;
   7 import java.io.FileOutputStream;
   8 import java.io.IOException;
   9 import java.io.InputStream;
  10 import java.net.MalformedURLException;
  11 import java.net.URL;
  12 import java.security.NoSuchAlgorithmException;
  13 import java.time.ZonedDateTime;
  14 import java.util.Collections;
  15 import java.util.EnumSet;
  16 import java.util.HashMap;
  17 import java.util.HashSet;
  18 import java.util.Iterator;
  19 import java.util.LinkedHashSet;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.Map.Entry;
  23 import java.util.Properties;
  24 import java.util.Set;
  25 import java.util.regex.Matcher;
  26 import java.util.regex.Pattern;
  27 import javax.persistence.Embeddable;
  28 import javax.persistence.Entity;
  29 import javax.persistence.MappedSuperclass;
  30 import javax.persistence.spi.PersistenceUnitTransactionType;
  31 import org.apache.maven.artifact.Artifact;
  32 import org.apache.maven.model.Resource;
  33 import org.apache.maven.plugin.AbstractMojo;
  34 import org.apache.maven.plugin.MojoExecutionException;
  35 import org.apache.maven.plugin.MojoFailureException;
  36 import org.apache.maven.project.MavenProject;
  37 import org.hibernate.boot.MetadataBuilder;
  38 import org.hibernate.boot.MetadataSources;
  39 import org.hibernate.boot.cfgxml.internal.ConfigLoader;
  40 import org.hibernate.boot.cfgxml.spi.LoadedConfig;
  41 import org.hibernate.boot.cfgxml.spi.MappingReference;
  42 import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
  43 import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
  44 import org.hibernate.boot.registry.BootstrapServiceRegistry;
  45 import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
  46 import org.hibernate.boot.registry.StandardServiceRegistry;
  47 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
  48 import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
  49 import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
  50 import org.hibernate.boot.registry.selector.spi.StrategySelector;
  51 import org.hibernate.boot.spi.MetadataImplementor;
  52 import org.hibernate.cfg.AvailableSettings;
  53 import static org.hibernate.cfg.AvailableSettings.DIALECT;
  54 import static org.hibernate.cfg.AvailableSettings.DRIVER;
  55 import static org.hibernate.cfg.AvailableSettings.FORMAT_SQL;
  56 import static org.hibernate.cfg.AvailableSettings.HBM2DDL_DELIMITER;
  57 import static org.hibernate.cfg.AvailableSettings.HBM2DLL_CREATE_NAMESPACES;
  58 import static org.hibernate.cfg.AvailableSettings.IMPLICIT_NAMING_STRATEGY;
  59 import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_DRIVER;
  60 import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_PASSWORD;
  61 import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_URL;
  62 import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_USER;
  63 import static org.hibernate.cfg.AvailableSettings.PASS;
  64 import static org.hibernate.cfg.AvailableSettings.PHYSICAL_NAMING_STRATEGY;
  65 import static org.hibernate.cfg.AvailableSettings.SHOW_SQL;
  66 import static org.hibernate.cfg.AvailableSettings.USER;
  67 import static org.hibernate.cfg.AvailableSettings.URL;
  68 import org.hibernate.engine.config.spi.ConfigurationService;
  69 import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
  70 import org.hibernate.internal.util.config.ConfigurationException;
  71 import org.hibernate.jpa.boot.internal.ParsedPersistenceXmlDescriptor;
  72 import org.hibernate.jpa.boot.internal.PersistenceXmlParser;
  73 import org.hibernate.tool.schema.TargetType;
  74 import org.hibernate.tool.schema.internal.ExceptionHandlerCollectingImpl;
  75 import org.hibernate.tool.schema.internal.exec.ScriptTargetOutputToFile;
  76 import org.hibernate.tool.schema.spi.ExecutionOptions;
  77 import org.hibernate.tool.schema.spi.SchemaManagementToolCoordinator;
  78 import org.hibernate.tool.schema.spi.ScriptTargetOutput;
  79 import org.hibernate.tool.schema.spi.TargetDescriptor;
  80 import org.scannotation.AnnotationDB;
  81
  82
  83 /**
  84  * Baseclass with common attributes and methods.
  85  *
  86  * @phase process-classes
  87  * @threadSafe
  88  * @requiresDependencyResolution runtime
  89  */
  90 public abstract class AbstractSchemaMojo extends AbstractMojo
  91 {
  92   public final static String EXECUTE = "hibernate.schema.execute";
  93   public final static String OUTPUTDIRECTORY = "project.build.outputDirectory";
  94   public final static String SCAN_CLASSES = "hibernate.schema.scan.classes";
  95   public final static String SCAN_DEPENDENCIES = "hibernate.schema.scan.dependencies";
  96   public final static String SCAN_TESTCLASSES = "hibernate.schema.scan.test_classes";
  97   public final static String TEST_OUTPUTDIRECTORY = "project.build.testOutputDirectory";
  98   public final static String SKIPPED = "hibernate.schema.skipped";
  99   public final static String SCRIPT = "hibernate.schema.script";
 100
 101   private final static Pattern SPLIT = Pattern.compile("[^,\\s]+");
 102
 103   private final Set<String> packages = new HashSet<String>();
 104
 105
 106   /**
 107    * The maven project.
 108    * <p>
 109    * Only needed internally.
 110    *
 111    * @parameter property="project"
 112    * @required
 113    * @readonly
 114    */
 115   private MavenProject project;
 116
 117   /**
 118    * Build-directory.
 119    * <p>
 120    * Only needed internally.
 121    *
 122    * @parameter property="project.build.directory"
 123    * @required
 124    * @readonly
 125    */
 126   private String buildDirectory;
 127
 128
 129   /** Parameters to configure the genaration of the SQL *********************/
 130
 131   /**
 132    * Excecute the generated SQL.
 133    * If set to <code>false</code>, only the SQL-script is created and the
 134    * database is not touched.
 135    * <p>
 136    * <strong>Important:</strong>
 137    * This configuration value can only be configured through the
 138    * <code>pom.xml</code>, or by the definition of a system-property, because
 139    * it is not known by Hibernate nor JPA and, hence, not picked up from
 140    * their configuration!
 141    *
 142    * @parameter property="hibernate.schema.execute" default-value="true"
 143    * @since 2.0
 144    */
 145   private Boolean execute;
 146
 147   /**
 148    * Skip execution
 149    * <p>
 150    * If set to <code>true</code>, the execution is skipped.
 151    * <p>
 152    * A skipped execution is signaled via the maven-property
 153    * <code>${hibernate.schema.skipped}</code>.
 154    * <p>
 155    * The execution is skipped automatically, if no modified or newly added
 156    * annotated classes are found and the dialect was not changed.
 157    * <p>
 158    * <strong>Important:</strong>
 159    * This configuration value can only be configured through the
 160    * <code>pom.xml</code>, or by the definition of a system-property, because
 161    * it is not known by Hibernate nor JPA and, hence, not picked up from
 162    * their configuration!
 163    *
 164    * @parameter property="hibernate.schema.skip" default-value="${maven.test.skip}"
 165    * @since 1.0
 166    */
 167   private boolean skip;
 168
 169   /**
 170    * Force generation/execution
 171    * <p>
 172    * Force the generation and (if configured) the execution of the SQL, even if
 173    * no modified or newly added annotated classes where found and the
 174    * configuration was not changed.
 175    * <p>
 176    * <code>skip</code> takes precedence over <code>force</code>.
 177    * <p>
 178    * <strong>Important:</strong>
 179    * This configuration value can only be configured through the
 180    * <code>pom.xml</code>, or by the definition of a system-property, because
 181    * it is not known by Hibernate nor JPA and, hence, not picked up from
 182    * their configuration!
 183    *
 184    * @parameter property="hibernate.schema.force" default-value="false"
 185    * @since 1.0
 186    */
 187   private boolean force;
 188
 189   /**
 190    * Hibernate dialect.
 191    *
 192    * @parameter property="hibernate.dialect"
 193    * @since 1.0
 194    */
 195   private String dialect;
 196
 197   /**
 198    * Delimiter in output-file.
 199    * <p>
 200    * <strong>Important:</strong>
 201    * This configuration value can only be configured through the
 202    * <code>pom.xml</code>, or by the definition of a system-property, because
 203    * it is not known by Hibernate nor JPA and, hence, not picked up from
 204    * their configuration!
 205    *
 206    * @parameter property="hibernate.hbm2ddl.delimiter" default-value=";"
 207    * @since 1.0
 208    */
 209   private String delimiter;
 210
 211   /**
 212    * Show the generated SQL in the command-line output.
 213    *
 214    * @parameter property="hibernate.show_sql"
 215    * @since 1.0
 216    */
 217   private Boolean show;
 218
 219   /**
 220    * Format output-file.
 221    *
 222    * @parameter property="hibernate.format_sql"
 223    * @since 1.0
 224    */
 225   private Boolean format;
 226
 227   /**
 228    * Specifies whether to automatically create also the database schema/catalog.
 229    *
 230    * @parameter property="hibernate.hbm2dll.create_namespaces" default-value="false"
 231    * @since 2.0
 232    */
 233   private Boolean createNamespaces;
 234
 235   /**
 236    * Implicit naming strategy
 237    *
 238    * @parameter property="hibernate.implicit_naming_strategy"
 239    * @since 2.0
 240    */
 241   private String implicitNamingStrategy;
 242
 243   /**
 244    * Physical naming strategy
 245    *
 246    * @parameter property="hibernate.physical_naming_strategy"
 247    * @since 2.0
 248    */
 249   private String physicalNamingStrategy;
 250
 251   /**
 252    * Wether the project should be scanned for annotated-classes, or not
 253    * <p>
 254    * This parameter is intended to allow overwriting of the parameter
 255    * <code>exclude-unlisted-classes</code> of a <code>persistence-unit</code>.
 256    * If not specified, it defaults to <code>true</code>
 257    *
 258    * @parameter property="hibernate.schema.scan.classes"
 259    * @since 2.0
 260    */
 261   private Boolean scanClasses;
 262
 263   /**
 264    * Classes-Directory to scan.
 265    * <p>
 266    * This parameter defaults to the maven build-output-directory for classes.
 267    * Additionally, all dependencies are scanned for annotated classes.
 268    * <p>
 269    * <strong>Important:</strong>
 270    * This configuration value can only be configured through the
 271    * <code>pom.xml</code>, or by the definition of a system-property, because
 272    * it is not known by Hibernate nor JPA and, hence, not picked up from
 273    * their configuration!
 274    *
 275    * @parameter property="project.build.outputDirectory"
 276    * @since 1.0
 277    */
 278   private String outputDirectory;
 279
 280   /**
 281    * Dependency-Scopes, that should be scanned for annotated classes.
 282    * <p>
 283    * By default, only dependencies in the scope <code>compile</code> are
 284    * scanned for annotated classes. Multiple scopes can be seperated by
 285    * white space or commas.
 286    * <p>
 287    * If you do not want any dependencies to be scanned for annotated
 288    * classes, set this parameter to <code>none</code>.
 289    * <p>
 290    * The plugin does not scan for annotated classes in transitive
 291    * dependencies. If some of your annotated classes are hidden in a
 292    * transitive dependency, you can simply add that dependency explicitly.
 293    *
 294    * @parameter property="hibernate.schema.scan.dependencies" default-value="compile"
 295    * @since 1.0.3
 296    */
 297   private String scanDependencies;
 298
 299   /**
 300    * Whether to scan the test-branch of the project for annotated classes, or
 301    * not.
 302    * <p>
 303    * If this parameter is set to <code>true</code> the test-classes of the
 304    * artifact will be scanned for hibernate-annotated classes additionally.
 305    * <p>
 306    * <strong>Important:</strong>
 307    * This configuration value can only be configured through the
 308    * <code>pom.xml</code>, or by the definition of a system-property, because
 309    * it is not known by Hibernate nor JPA and, hence, not picked up from
 310    * their configuration!
 311    *
 312    * @parameter property="hibernate.schema.scan.test_classes" default-value="false"
 313    * @since 1.0.1
 314    */
 315   private Boolean scanTestClasses;
 316
 317   /**
 318    * Test-Classes-Directory to scan.
 319    * <p>
 320    * This parameter defaults to the maven build-output-directory for
 321    * test-classes.
 322    * <p>
 323    * This parameter is only used, when <code>scanTestClasses</code> is set
 324    * to <code>true</code>!
 325    * <p>
 326    * <strong>Important:</strong>
 327    * This configuration value can only be configured through the
 328    * <code>pom.xml</code>, or by the definition of a system-property, because
 329    * it is not known by Hibernate nor JPA and, hence, not picked up from
 330    * their configuration!
 331    *
 332    * @parameter property="project.build.testOutputDirectory"
 333    * @since 1.0.2
 334    */
 335   private String testOutputDirectory;
 336
 337
 338   /** Conection parameters *************************************************/
 339
 340   /**
 341    * SQL-Driver name.
 342    *
 343    * @parameter property="hibernate.connection.driver_class"
 344    * @since 1.0
 345    */
 346   private String driver;
 347
 348   /**
 349    * Database URL.
 350    *
 351    * @parameter property="hibernate.connection.url"
 352    * @since 1.0
 353    */
 354   private String url;
 355
 356   /**
 357    * Database username
 358    *
 359    * @parameter property="hibernate.connection.username"
 360    * @since 1.0
 361    */
 362   private String username;
 363
 364   /**
 365    * Database password
 366    *
 367    * @parameter property="hibernate.connection.password"
 368    * @since 1.0
 369    */
 370   private String password;
 371
 372
 373   /** Parameters to locate configuration sources ****************************/
 374
 375   /**
 376    * Path to a file or name of a ressource with hibernate properties.
 377    * If this parameter is specified, the plugin will try to load configuration
 378    * values from a file with the given path or a ressource on the classpath with
 379    * the given name. If both fails, the execution of the plugin will fail.
 380    * <p>
 381    * If this parameter is not set the plugin will load configuration values
 382    * from a ressource named <code>hibernate.properties</code> on the classpath,
 383    * if it is present, but will not fail if there is no such ressource.
 384    * <p>
 385    * During ressource-lookup, the test-classpath takes precedence.
 386    *
 387    * @parameter
 388    * @since 1.0
 389    */
 390   private String hibernateProperties;
 391
 392   /**
 393    * Path to Hibernate configuration file (.cfg.xml).
 394    * If this parameter is specified, the plugin will try to load configuration
 395    * values from a file with the given path or a ressource on the classpath with
 396    * the given name. If both fails, the execution of the plugin will fail.
 397    * <p>
 398    * If this parameter is not set the plugin will load configuration values
 399    * from a ressource named <code>hibernate.cfg.xml</code> on the classpath,
 400    * if it is present, but will not fail if there is no such ressource.
 401    * <p>
 402    * During ressource-lookup, the test-classpath takes precedence.
 403    * <p>
 404    * Settings in this file will overwrite settings in the properties file.
 405    *
 406    * @parameter
 407    * @since 1.1.0
 408    */
 409   private String hibernateConfig;
 410
 411   /**
 412    * Name of the persistence-unit.
 413    * If this parameter is specified, the plugin will try to load configuration
 414    * values from a persistence-unit with the specified name. If no such
 415    * persistence-unit can be found, the plugin will throw an exception.
 416    * <p>
 417    * If this parameter is not set and there is only one persistence-unit
 418    * available, that unit will be used automatically. But if this parameter is
 419    * not set and there are multiple persistence-units available on,
 420    * the class-path, the execution of the plugin will fail.
 421    * <p>
 422    * Settings in this file will overwrite settings in the properties or the
 423    * configuration file.
 424    *
 425    * @parameter
 426    * @since 1.1.0
 427    */
 428   private String persistenceUnit;
 429
 430   /**
 431    * List of Hibernate-Mapping-Files (XML).
 432    * Multiple files can be separated with white-spaces and/or commas.
 433    *
 434    * @parameter property="hibernate.mapping"
 435    * @since 1.0.2
 436    */
 437   private String mappings;
 438
 439
 440
 441   public final void execute(String filename)
 442     throws
 443       MojoFailureException,
 444       MojoExecutionException
 445   {
 446     if (skip)
 447     {
 448       getLog().info("Execution of hibernate-maven-plugin was skipped!");
 449       project.getProperties().setProperty(SKIPPED, "true");
 450       return;
 451     }
 452
 453     ModificationTracker tracker;
 454     try
 455     {
 456       tracker = new ModificationTracker(buildDirectory, filename, getLog());
 457     }
 458     catch (NoSuchAlgorithmException e)
 459     {
 460       throw new MojoFailureException("Digest-Algorithm MD5 is missing!", e);
 461     }
 462
 463     final SimpleConnectionProvider connectionProvider =
 464         new SimpleConnectionProvider(getLog());
 465
 466     try
 467     {
 468       /** Start extended logging */
 469       MavenLogAppender.startPluginLog(this);
 470
 471       /** Load checksums for old mapping and configuration */
 472       tracker.load();
 473
 474       /** Create the ClassLoader */
 475       MutableClassLoader classLoader = createClassLoader();
 476
 477       /** Create a BootstrapServiceRegistry with the created ClassLoader */
 478       BootstrapServiceRegistry bootstrapServiceRegitry =
 479           new BootstrapServiceRegistryBuilder()
 480               .applyClassLoader(classLoader)
 481               .build();
 482       ClassLoaderService classLoaderService =
 483           bootstrapServiceRegitry.getService(ClassLoaderService.class);
 484
 485       Properties properties = new Properties();
 486       ConfigLoader configLoader = new ConfigLoader(bootstrapServiceRegitry);
 487
 488       /** Loading and merging configuration */
 489       properties.putAll(loadProperties(configLoader));
 490       LoadedConfig config = loadConfig(configLoader);
 491       if (config != null)
 492         properties.putAll(config.getConfigurationValues());
 493       ParsedPersistenceXmlDescriptor unit =
 494           loadPersistenceUnit(classLoaderService, properties);
 495       if (unit != null)
 496         properties.putAll(unit.getProperties());
 497
 498       /** Overwriting/Completing configuration */
 499       configure(properties, tracker);
 500
 501       /** Check configuration for modifications */
 502       if(tracker.track(properties))
 503         getLog().debug("Configuration has changed.");
 504       else
 505         getLog().debug("Configuration unchanged.");
 506
 507       /** Check, that the outputfile is writable */
 508       final File output = getOutputFile(filename);
 509       /** Check, if the outputfile is missing or was changed */
 510       checkOutputFile(output, tracker);
 511
 512       /** Configure Hibernate */
 513       final StandardServiceRegistry serviceRegistry =
 514           new StandardServiceRegistryBuilder(bootstrapServiceRegitry)
 515               .applySettings(properties)
 516               .addService(ConnectionProvider.class, connectionProvider)
 517               .build();
 518       final MetadataSources sources = new MetadataSources(serviceRegistry);
 519
 520       /** Add the remaining class-path-elements */
 521       completeClassPath(classLoader);
 522
 523       /** Apply mappings from hibernate-configuration, if present */
 524       if (config != null)
 525       {
 526         for (MappingReference mapping : config.getMappingReferences())
 527           mapping.apply(sources);
 528       }
 529
 530       Set<String> classes;
 531       if (unit == null)
 532       {
 533         /** No persistent unit: default behaviour */
 534         if (scanClasses == null)
 535           scanClasses = true;
 536         Set<URL> urls = new HashSet<URL>();
 537         if (scanClasses)
 538           addRoot(urls, outputDirectory);
 539         if (scanTestClasses)
 540           addRoot(urls, testOutputDirectory);
 541         addDependencies(urls);
 542         classes = scanUrls(urls);
 543       }
 544       else
 545       {
 546         /** Follow configuration in persisten unit */
 547         if (scanClasses == null)
 548           scanClasses = !unit.isExcludeUnlistedClasses();
 549         Set<URL> urls = new HashSet<URL>();
 550         if (scanClasses)
 551         {
 552           /**
 553            * Scan the root of the persiten unit and configured jars for
 554            * annotated classes
 555            */
 556           urls.add(unit.getPersistenceUnitRootUrl());
 557           for (URL url : unit.getJarFileUrls())
 558             urls.add(url);
 559         }
 560         if (scanTestClasses)
 561           addRoot(urls, testOutputDirectory);
 562         classes = scanUrls(urls);
 563         for (String className : unit.getManagedClassNames())
 564           classes.add(className);
 565         /**
 566          * Add mappings from the default mapping-file
 567          * <code>META-INF/orm.xml</code>, if present
 568          */
 569         boolean error = false;
 570         InputStream is;
 571         is = classLoader.getResourceAsStream("META-INF/orm.xml");
 572         if (is != null)
 573         {
 574           getLog().info("Adding default JPA-XML-mapping from META-INF/orm.xml");
 575           try
 576           {
 577             tracker.track("META-INF/orm.xml", is);
 578             sources.addResource("META-INF/orm.xml");
 579           }
 580           catch (IOException e)
 581           {
 582             getLog().error("cannot read META-INF/orm.xml: " + e);
 583             error = true;
 584           }
 585         }
 586         else
 587         {
 588           getLog().debug("no META-INF/orm.xml found");
 589         }
 590         /**
 591          * Add mappings from files, that are explicitly configured in the
 592          * persistence unit
 593          */
 594         for (String mapping : unit.getMappingFileNames())
 595         {
 596           getLog().info("Adding explicitly configured mapping from " + mapping);
 597           is = classLoader.getResourceAsStream(mapping);
 598           if (is != null)
 599           {
 600             try
 601             {
 602               tracker.track(mapping, is);
 603               sources.addResource(mapping);
 604             }
 605             catch (IOException e)
 606             {
 607               getLog().info("cannot read mapping-file " + mapping + ": " + e);
 608               error = true;
 609             }
 610           }
 611           else
 612           {
 613             getLog().error("cannot find mapping-file " + mapping);
 614             error = true;
 615           }
 616         }
 617         if (error)
 618           throw new MojoFailureException(
 619               "error, while reading mappings configured in persistence-unit \"" +
 620               unit.getName() +
 621               "\""
 622               );
 623       }
 624
 625       /** Add the configured/collected annotated classes */
 626       for (String className : classes)
 627         addAnnotated(className, sources, classLoaderService, tracker);
 628
 629       /** Add explicitly configured classes */
 630       addMappings(sources, tracker);
 631
 632       /** Skip execution, if mapping and configuration is unchanged */
 633       if (!tracker.modified())
 634       {
 635         getLog().info("Mapping and configuration unchanged.");
 636         if (force)
 637           getLog().info("Generation/execution is forced!");
 638         else
 639         {
 640           getLog().info("Skipping schema generation!");
 641           project.getProperties().setProperty(SKIPPED, "true");
 642           return;
 643         }
 644       }
 645
 646
 647       /** Truncate output file */
 648       try
 649       {
 650         new FileOutputStream(output).getChannel().truncate(0).close();
 651       }
 652       catch (IOException e)
 653       {
 654         String error =
 655             "Error while truncating " + output.getAbsolutePath() + ": "
 656             + e.getMessage();
 657         getLog().warn(error);
 658         throw new MojoExecutionException(error);
 659       }
 660
 661       /** Create a connection, if sufficient configuration infromation is available */
 662       connectionProvider.open(classLoaderService, properties);
 663
 664       MetadataBuilder metadataBuilder = sources.getMetadataBuilder();
 665
 666       StrategySelector strategySelector =
 667           serviceRegistry.getService(StrategySelector.class);
 668
 669       if (properties.containsKey(IMPLICIT_NAMING_STRATEGY))
 670       {
 671         metadataBuilder.applyImplicitNamingStrategy(
 672             strategySelector.resolveStrategy(
 673                 ImplicitNamingStrategy.class,
 674                 properties.getProperty(IMPLICIT_NAMING_STRATEGY)
 675                 )
 676             );
 677       }
 678
 679       if (properties.containsKey(PHYSICAL_NAMING_STRATEGY))
 680       {
 681         metadataBuilder.applyPhysicalNamingStrategy(
 682             strategySelector.resolveStrategy(
 683                 PhysicalNamingStrategy.class,
 684                 properties.getProperty(PHYSICAL_NAMING_STRATEGY)
 685                 )
 686             );
 687       }
 688
 689       /** Prepare the generation of the SQL */
 690       Map settings = new HashMap();
 691       settings.putAll(
 692           serviceRegistry
 693               .getService(ConfigurationService.class)
 694               .getSettings()
 695               );
 696       ExceptionHandlerCollectingImpl handler =
 697           new ExceptionHandlerCollectingImpl();
 698       ExecutionOptions options =
 699           SchemaManagementToolCoordinator
 700               .buildExecutionOptions(settings, handler);
 701       final EnumSet<TargetType> targetTypes = EnumSet.of(TargetType.SCRIPT);
 702       if (execute)
 703         targetTypes.add(TargetType.DATABASE);
 704       TargetDescriptor target = new TargetDescriptor()
 705       {
 706         @Override
 707         public EnumSet<TargetType> getTargetTypes()
 708         {
 709           return targetTypes;
 710         }
 711
 712         @Override
 713         public ScriptTargetOutput getScriptTargetOutput()
 714         {
 715           String charset =
 716               (String)
 717               serviceRegistry
 718                   .getService(ConfigurationService.class)
 719                   .getSettings()
 720                   .get(AvailableSettings.HBM2DDL_CHARSET_NAME);
 721           return new ScriptTargetOutputToFile(output, charset);
 722         }
 723       };
 724
 725       /**
 726        * Change class-loader of current thread.
 727        * This is necessary, because still not all parts of Hibernate 5 use
 728        * the newly introduced ClassLoaderService and will fail otherwise!
 729        */
 730       Thread thread = Thread.currentThread();
 731       ClassLoader contextClassLoader = thread.getContextClassLoader();
 732       try
 733       {
 734         thread.setContextClassLoader(classLoader);
 735         build((MetadataImplementor)metadataBuilder.build(), options, target);
 736         if (handler.getExceptions().size() > 0)
 737         {
 738           StringBuilder builder = new StringBuilder();
 739           builder.append("Hibernate failed:");
 740           for (Exception e : handler.getExceptions())
 741           {
 742             builder.append("\n * ");
 743             builder.append(e.getMessage());
 744           }
 745           String error = builder.toString();
 746           getLog().error(error);
 747           throw new MojoFailureException(error);
 748         }
 749       }
 750       finally
 751       {
 752         thread.setContextClassLoader(contextClassLoader);
 753         /** Track, the content of the generated script */
 754         checkOutputFile(output, tracker);
 755       }
 756     }
 757     catch (MojoExecutionException e)
 758     {
 759       tracker.failed();
 760       throw e;
 761     }
 762     catch (MojoFailureException e)
 763     {
 764       tracker.failed();
 765       throw e;
 766     }
 767     catch (RuntimeException e)
 768     {
 769       tracker.failed();
 770       throw e;
 771     }
 772     finally
 773     {
 774       /** Remember mappings and configuration */
 775       tracker.save();
 776
 777       /** Close the connection - if one was opened */
 778       connectionProvider.close();
 779
 780       /** Stop Log-Capturing */
 781       MavenLogAppender.endPluginLog(this);
 782     }
 783   }
 784
 785
 786   abstract void build(
 787       MetadataImplementor metadata,
 788       ExecutionOptions options,
 789       TargetDescriptor target
 790       )
 791     throws
 792       MojoFailureException,
 793       MojoExecutionException;
 794
 795
 796   private MutableClassLoader createClassLoader() throws MojoExecutionException
 797   {
 798     try
 799     {
 800       getLog().debug("Creating ClassLoader for project-dependencies...");
 801       LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
 802       File file;
 803
 804       file = new File(testOutputDirectory);
 805       if (!file.exists())
 806       {
 807         getLog().info("Creating test-output-directory: " + testOutputDirectory);
 808         file.mkdirs();
 809       }
 810       urls.add(file.toURI().toURL());
 811
 812       file = new File(outputDirectory);
 813       if (!file.exists())
 814       {
 815         getLog().info("Creating output-directory: " + outputDirectory);
 816         file.mkdirs();
 817       }
 818       urls.add(file.toURI().toURL());
 819
 820       return new MutableClassLoader(urls, getLog());
 821     }
 822     catch (Exception e)
 823     {
 824       getLog().error("Error while creating ClassLoader!", e);
 825       throw new MojoExecutionException(e.getMessage());
 826     }
 827   }
 828
 829   private void completeClassPath(MutableClassLoader classLoader)
 830       throws
 831         MojoExecutionException
 832   {
 833     try
 834     {
 835       getLog().debug("Completing class-paths of the ClassLoader for project-dependencies...");
 836       List<String> classpathFiles = project.getCompileClasspathElements();
 837       if (scanTestClasses)
 838         classpathFiles.addAll(project.getTestClasspathElements());
 839       LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
 840       for (String pathElement : classpathFiles)
 841       {
 842         getLog().debug("Dependency: " + pathElement);
 843         urls.add(new File(pathElement).toURI().toURL());
 844       }
 845       classLoader.add(urls);
 846     }
 847     catch (Exception e)
 848     {
 849       getLog().error("Error while creating ClassLoader!", e);
 850       throw new MojoExecutionException(e.getMessage());
 851     }
 852   }
 853
 854   private Map loadProperties(ConfigLoader configLoader)
 855       throws
 856         MojoExecutionException
 857   {
 858     /** Try to read configuration from properties-file */
 859     if (hibernateProperties == null)
 860     {
 861       try
 862       {
 863         return configLoader.loadProperties("hibernate.properties");
 864       }
 865       catch (ConfigurationException e)
 866       {
 867         getLog().debug(e.getMessage());
 868         return Collections.EMPTY_MAP;
 869       }
 870     }
 871     else
 872     {
 873       try
 874       {
 875         File file = new File(hibernateProperties);
 876         if (file.exists())
 877         {
 878           getLog().info("Reading settings from file " + hibernateProperties + "...");
 879           return configLoader.loadProperties(file);
 880         }
 881         else
 882           return configLoader.loadProperties(hibernateProperties);
 883       }
 884       catch (ConfigurationException e)
 885       {
 886         getLog().error("Error while reading properties!", e);
 887         throw new MojoExecutionException(e.getMessage());
 888       }
 889     }
 890   }
 891
 892   private LoadedConfig loadConfig(ConfigLoader configLoader)
 893       throws MojoExecutionException
 894   {
 895     /** Try to read configuration from configuration-file */
 896     if (hibernateConfig == null)
 897     {
 898       try
 899       {
 900         return configLoader.loadConfigXmlResource("hibernate.cfg.xml");
 901       }
 902       catch (ConfigurationException e)
 903       {
 904         getLog().debug(e.getMessage());
 905         return null;
 906       }
 907     }
 908     else
 909     {
 910       try
 911       {
 912         File file = new File(hibernateConfig);
 913         if (file.exists())
 914         {
 915           getLog().info("Reading configuration from file " + hibernateConfig + "...");
 916           return configLoader.loadConfigXmlFile(file);
 917         }
 918         else
 919         {
 920           return configLoader.loadConfigXmlResource(hibernateConfig);
 921         }
 922       }
 923       catch (ConfigurationException e)
 924       {
 925         getLog().error("Error while reading configuration!", e);
 926         throw new MojoExecutionException(e.getMessage());
 927       }
 928     }
 929   }
 930
 931   private void configure(Properties properties, ModificationTracker tracker)
 932       throws MojoFailureException
 933   {
 934     /**
 935      * Special treatment for the configuration-value "execute": if it is
 936      * switched to "true", the genearation fo the schema should be forced!
 937      */
 938     if (tracker.check(EXECUTE, execute.toString()) && execute)
 939     {
 940       getLog().info(
 941           "hibernate.schema.execute was switched on: " +
 942           "forcing generation/execution of SQL"
 943           );
 944       tracker.touch();
 945     }
 946     configure(properties, execute, EXECUTE);
 947
 948     /**
 949      * Configure the generation of the SQL.
 950      * Overwrite values from properties-file if the configuration parameter is
 951      * known to Hibernate.
 952      */
 953     configure(properties, dialect, DIALECT);
 954     configure(properties, delimiter, HBM2DDL_DELIMITER);
 955     configure(properties, format, FORMAT_SQL);
 956     configure(properties, createNamespaces, HBM2DLL_CREATE_NAMESPACES);
 957     configure(properties, implicitNamingStrategy, IMPLICIT_NAMING_STRATEGY);
 958     configure(properties, physicalNamingStrategy, PHYSICAL_NAMING_STRATEGY);
 959     configure(properties, outputDirectory, OUTPUTDIRECTORY);
 960     configure(properties, scanDependencies, SCAN_DEPENDENCIES);
 961     configure(properties, scanTestClasses, SCAN_TESTCLASSES);
 962     configure(properties, testOutputDirectory, TEST_OUTPUTDIRECTORY);
 963
 964     /**
 965      * Special treatment for the configuration-value "show": a change of its
 966      * configured value should not lead to a regeneration of the database
 967      * schama!
 968      */
 969     if (show == null)
 970       show = Boolean.valueOf(properties.getProperty(SHOW_SQL));
 971     else
 972       properties.setProperty(SHOW_SQL, show.toString());
 973
 974     /**
 975      * Configure the connection parameters.
 976      * Overwrite values from properties-file.
 977      */
 978     configure(properties, driver, DRIVER, JPA_JDBC_DRIVER);
 979     configure(properties, url, URL, JPA_JDBC_URL);
 980     configure(properties, username, USER, JPA_JDBC_USER);
 981     configure(properties, password, PASS, JPA_JDBC_PASSWORD);
 982
 983     if (properties.isEmpty())
 984     {
 985       getLog().error("No properties set!");
 986       throw new MojoFailureException("Hibernate configuration is missing!");
 987     }
 988
 989     getLog().info("Gathered configuration:");
 990     for (Entry<Object,Object> entry : properties.entrySet())
 991       getLog().info("  " + entry.getKey() + " = " + entry.getValue());
 992   }
 993
 994   private void configure(
 995       Properties properties,
 996       String value,
 997       String key,
 998       String alternativeKey
 999       )
1000   {
1001     configure(properties, value, key);
1002
1003     if (properties.containsKey(alternativeKey))
1004     {
1005       if (properties.containsKey(key))
1006       {
1007         getLog().warn(
1008             "Ignoring property " + alternativeKey + "=\"" +
1009             properties.getProperty(alternativeKey) +
1010             "\" in favour for property " + key + "=\"" +
1011             properties.getProperty(key) + "\""
1012             );
1013         properties.remove(alternativeKey);
1014       }
1015       else
1016       {
1017         value = properties.getProperty(alternativeKey);
1018         properties.remove(alternativeKey);
1019         getLog().info(
1020             "Using value \"" + value + "\" from property " + alternativeKey +
1021             " for property " + key
1022             );
1023         properties.setProperty(key, value);
1024       }
1025     }
1026   }
1027
1028   private void configure(Properties properties, String value, String key)
1029   {
1030     if (value != null)
1031     {
1032       if (properties.containsKey(key))
1033       {
1034         if (!properties.getProperty(key).equals(value))
1035         {
1036           getLog().info(
1037               "Overwriting property " + key + "=\"" +
1038               properties.getProperty(key) +
1039               "\" with value \"" + value + "\""
1040               );
1041           properties.setProperty(key, value);
1042         }
1043       }
1044       else
1045       {
1046         getLog().debug("Using value \"" + value + "\" for property " + key);
1047         properties.setProperty(key, value);
1048       }
1049     }
1050   }
1051
1052   private void configure(Properties properties, Boolean value, String key)
1053   {
1054     configure(properties, value == null ? null : value.toString(), key);
1055   }
1056
1057   private File getOutputFile(String filename)
1058       throws
1059         MojoExecutionException
1060   {
1061     File output = new File(filename);
1062
1063     if (!output.isAbsolute())
1064     {
1065       // Interpret relative file path relative to build directory
1066       output = new File(buildDirectory, filename);
1067     }
1068     getLog().debug("Output file: " + output.getPath());
1069
1070     // Ensure that directory path for specified file exists
1071     File outFileParentDir = output.getParentFile();
1072     if (null != outFileParentDir && !outFileParentDir.exists())
1073     {
1074       try
1075       {
1076         getLog().info(
1077             "Creating directory path for output file:" +
1078             outFileParentDir.getPath()
1079             );
1080         outFileParentDir.mkdirs();
1081       }
1082       catch (Exception e)
1083       {
1084         String error =
1085             "Error creating directory path for output file: " + e.getMessage();
1086         getLog().error(error);
1087         throw new MojoExecutionException(error);
1088       }
1089     }
1090
1091     try
1092     {
1093       output.createNewFile();
1094     }
1095     catch (IOException e)
1096     {
1097       String error = "Error creating output file: " + e.getMessage();
1098       getLog().error(error);
1099       throw new MojoExecutionException(error);
1100     }
1101
1102     if (!output.canWrite())
1103     {
1104       String error =
1105           "Output file " + output.getAbsolutePath() + " is not writable!";
1106       getLog().error(error);
1107       throw new MojoExecutionException(error);
1108     }
1109
1110     return output;
1111   }
1112
1113   private void checkOutputFile(File output, ModificationTracker tracker)
1114       throws
1115         MojoExecutionException
1116   {
1117     try
1118     {
1119       if (output.exists())
1120         tracker.track(SCRIPT, new FileInputStream(output));
1121       else
1122         tracker.track(SCRIPT, ZonedDateTime.now().toString());
1123     }
1124     catch (IOException e)
1125     {
1126       String error =
1127           "Error while checking the generated script: " + e.getMessage();
1128       getLog().error(error);
1129       throw new MojoExecutionException(error);
1130     }
1131   }
1132
1133   private void addMappings(MetadataSources sources, ModificationTracker tracker)
1134       throws MojoFailureException
1135   {
1136     getLog().debug("Adding explicitly configured mappings...");
1137     if (mappings != null)
1138     {
1139       try
1140       {
1141         for (String filename : mappings.split("[\\s,]+"))
1142         {
1143           // First try the filename as absolute/relative path
1144           File file = new File(filename);
1145           if (!file.exists())
1146           {
1147             // If the file was not found, search for it in the resource-directories
1148             for (Resource resource : project.getResources())
1149             {
1150               file = new File(resource.getDirectory() + File.separator + filename);
1151               if (file.exists())
1152                 break;
1153             }
1154           }
1155           if (file.exists())
1156           {
1157             if (file.isDirectory())
1158               // TODO: add support to read all mappings under a directory
1159               throw new MojoFailureException(file.getAbsolutePath() + " is a directory");
1160             if (tracker.track(filename, new FileInputStream(file)))
1161               getLog().debug("Found new or modified mapping-file: " + filename);
1162             else
1163               getLog().debug("Mapping-file unchanged: " + filename);
1164
1165             sources.addFile(file);
1166           }
1167           else
1168             throw new MojoFailureException("File " + filename + " could not be found in any of the configured resource-directories!");
1169         }
1170       }
1171       catch (IOException e)
1172       {
1173         throw new MojoFailureException("Cannot calculate MD5 sums!", e);
1174       }
1175     }
1176   }
1177
1178   private void addRoot(Set<URL> urls, String path) throws MojoFailureException
1179   {
1180     try
1181     {
1182       File dir = new File(path);
1183       if (dir.exists())
1184       {
1185         getLog().info("Adding " + dir.getAbsolutePath() + " to the list of roots to scan...");
1186         urls.add(dir.toURI().toURL());
1187       }
1188     }
1189     catch (MalformedURLException e)
1190     {
1191       getLog().error("error while adding the project-root to the list of roots to scan!", e);
1192       throw new MojoFailureException(e.getMessage());
1193     }
1194   }
1195
1196   private void addDependencies(Set<URL> urls) throws MojoFailureException
1197   {
1198     try
1199     {
1200       if (scanDependencies != null)
1201       {
1202         Matcher matcher = SPLIT.matcher(scanDependencies);
1203         while (matcher.find())
1204         {
1205           getLog().info("Adding dependencies from scope " + matcher.group() + " to the list of roots to scan");
1206           for (Artifact artifact : project.getDependencyArtifacts())
1207           {
1208             if (!artifact.getScope().equalsIgnoreCase(matcher.group()))
1209               continue;
1210             if (artifact.getFile() == null)
1211             {
1212               getLog().warn("Cannot add dependency " + artifact.getId() + ": no JAR-file available!");
1213               continue;
1214             }
1215             getLog().info("Adding dependencies from scope " + artifact.getId() + " to the list of roots to scan");
1216             urls.add(artifact.getFile().toURI().toURL());
1217           }
1218         }
1219       }
1220     }
1221     catch (MalformedURLException e)
1222     {
1223       getLog().error("Error while adding dependencies to the list of roots to scan!", e);
1224       throw new MojoFailureException(e.getMessage());
1225     }
1226   }
1227
1228   private Set<String> scanUrls(Set<URL> scanRoots)
1229       throws
1230         MojoFailureException
1231   {
1232     try
1233     {
1234       AnnotationDB db = new AnnotationDB();
1235       for (URL root : scanRoots)
1236         db.scanArchives(root);
1237
1238       Set<String> classes = new HashSet<String>();
1239       if (db.getAnnotationIndex().containsKey(Entity.class.getName()))
1240         classes.addAll(db.getAnnotationIndex().get(Entity.class.getName()));
1241       if (db.getAnnotationIndex().containsKey(MappedSuperclass.class.getName()))
1242         classes.addAll(db.getAnnotationIndex().get(MappedSuperclass.class.getName()));
1243       if (db.getAnnotationIndex().containsKey(Embeddable.class.getName()))
1244         classes.addAll(db.getAnnotationIndex().get(Embeddable.class.getName()));
1245
1246       return classes;
1247     }
1248     catch (Exception e)
1249     {
1250       getLog().error("Error while scanning!", e);
1251       throw new MojoFailureException(e.getMessage());
1252     }
1253   }
1254
1255   private void addAnnotated(
1256       String name,
1257       MetadataSources sources,
1258       ClassLoaderService classLoaderService,
1259       ModificationTracker tracker
1260       )
1261       throws
1262         MojoFailureException,
1263         MojoExecutionException
1264   {
1265     try
1266     {
1267       getLog().info("Adding annotated resource: " + name);
1268       String packageName = null;
1269
1270       boolean error = false;
1271       try
1272       {
1273         Class<?> annotatedClass = classLoaderService.classForName(name);
1274         String resourceName = annotatedClass.getName();
1275         resourceName =
1276             resourceName.substring(
1277                 resourceName.lastIndexOf(".") + 1,
1278                 resourceName.length()
1279                 ) + ".class";
1280         InputStream is = annotatedClass.getResourceAsStream(resourceName);
1281         if (is != null)
1282         {
1283           if (tracker.track(name, is))
1284             getLog().debug("New or modified class: " + name);
1285           else
1286             getLog().debug("Unchanged class: " + name);
1287           sources.addAnnotatedClass(annotatedClass);
1288           packageName = annotatedClass.getPackage().getName();
1289         }
1290         else
1291         {
1292           getLog().error("cannot find ressource " + resourceName + " for class " + name);
1293           error = true;
1294         }
1295       }
1296       catch(ClassLoadingException e)
1297       {
1298         packageName = name;
1299       }
1300       if (error)
1301       {
1302         throw new MojoExecutionException("error while inspecting annotated class " + name);
1303       }
1304
1305       while (packageName != null)
1306       {
1307         if (packages.contains(packageName))
1308           return;
1309         String resource = packageName.replace('.', '/') + "/package-info.class";
1310         InputStream is = classLoaderService.locateResourceStream(resource);
1311         if (is == null)
1312         {
1313           // No compiled package-info available: no package-level annotations!
1314           getLog().debug("Package " + packageName + " is not annotated.");
1315         }
1316         else
1317         {
1318           if (tracker.track(packageName, is))
1319             getLog().debug("New or modified package: " + packageName);
1320           else
1321            getLog().debug("Unchanged package: " + packageName);
1322           getLog().info("Adding annotations from package " + packageName);
1323           sources.addPackage(packageName);
1324         }
1325         packages.add(packageName);
1326         int i = packageName.lastIndexOf('.');
1327         if (i < 0)
1328           packageName = null;
1329         else
1330           packageName = packageName.substring(0,i);
1331       }
1332     }
1333     catch (Exception e)
1334     {
1335       getLog().error("Error while adding the annotated class " + name, e);
1336       throw new MojoFailureException(e.getMessage());
1337     }
1338   }
1339
1340   private ParsedPersistenceXmlDescriptor loadPersistenceUnit(
1341       ClassLoaderService classLoaderService,
1342       Properties properties
1343       )
1344       throws
1345         MojoFailureException
1346   {
1347     PersistenceXmlParser parser =
1348         new PersistenceXmlParser(
1349             classLoaderService,
1350             PersistenceUnitTransactionType.RESOURCE_LOCAL
1351              );
1352
1353     Map<String, ParsedPersistenceXmlDescriptor> units =
1354         parser.doResolve(properties);
1355
1356     if (persistenceUnit == null)
1357     {
1358       Iterator<String> names = units.keySet().iterator();
1359       if (!names.hasNext())
1360       {
1361         getLog().info("Found no META-INF/persistence.xml.");
1362         return null;
1363       }
1364
1365       String name = names.next();
1366       if (!names.hasNext())
1367       {
1368           getLog().info("Using persistence-unit " + name);
1369           return units.get(name);
1370       }
1371
1372       StringBuilder builder = new StringBuilder();
1373       builder.append("No name provided and multiple persistence units found: ");
1374       builder.append(name);
1375       while(names.hasNext())
1376       {
1377         builder.append(", ");
1378         builder.append(names.next());
1379       }
1380       builder.append('.');
1381       throw new MojoFailureException(builder.toString());
1382     }
1383
1384     if (units.containsKey(persistenceUnit))
1385     {
1386       getLog().info("Using configured persistence-unit " + persistenceUnit);
1387       return units.get(persistenceUnit);
1388     }
1389
1390     throw new MojoFailureException("Could not find persistence-unit " + persistenceUnit);
1391   }
1392 }