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

   1 package de.juplo.plugins.hibernate4;
   2
   3 /*
   4  * Copyright 2001-2005 The Apache Software Foundation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 import com.pyx4j.log4j.MavenLogAppender;
  20 import java.io.File;
  21 import java.io.FileInputStream;
  22 import java.io.FileNotFoundException;
  23 import java.io.FileOutputStream;
  24 import java.io.IOException;
  25 import java.io.InputStream;
  26 import java.io.ObjectInputStream;
  27 import java.io.ObjectOutputStream;
  28 import java.math.BigInteger;
  29 import java.net.URL;
  30 import java.net.URLClassLoader;
  31 import java.security.MessageDigest;
  32 import java.security.NoSuchAlgorithmException;
  33 import java.sql.Driver;
  34 import java.sql.DriverPropertyInfo;
  35 import java.sql.SQLException;
  36 import java.sql.SQLFeatureNotSupportedException;
  37 import java.util.Collections;
  38 import java.util.Comparator;
  39 import java.util.HashMap;
  40 import java.util.HashSet;
  41 import java.util.LinkedHashSet;
  42 import java.util.LinkedList;
  43 import java.util.List;
  44 import java.util.Map;
  45 import java.util.Map.Entry;
  46 import java.util.Properties;
  47 import java.util.Set;
  48 import java.util.TreeSet;
  49 import java.util.logging.Logger;
  50 import java.util.regex.Matcher;
  51 import java.util.regex.Pattern;
  52 import javax.persistence.Embeddable;
  53 import javax.persistence.Entity;
  54 import javax.persistence.MappedSuperclass;
  55 import javax.persistence.spi.PersistenceUnitTransactionType;
  56 import org.apache.maven.artifact.Artifact;
  57 import org.apache.maven.model.Resource;
  58 import org.apache.maven.plugin.AbstractMojo;
  59 import org.apache.maven.plugin.MojoExecutionException;
  60 import org.apache.maven.plugin.MojoFailureException;
  61 import org.apache.maven.project.MavenProject;
  62 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
  63 import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
  64 import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
  65 import org.hibernate.boot.registry.internal.StandardServiceRegistryImpl;
  66 import org.hibernate.cfg.Environment;
  67 import org.hibernate.cfg.NamingStrategy;
  68 import org.hibernate.envers.configuration.spi.AuditConfiguration;
  69 import org.hibernate.internal.util.config.ConfigurationHelper;
  70 import org.hibernate.jpa.boot.internal.ParsedPersistenceXmlDescriptor;
  71 import org.hibernate.jpa.boot.internal.PersistenceXmlParser;
  72 import org.hibernate.jpa.boot.spi.ProviderChecker;
  73 import org.hibernate.tool.hbm2ddl.SchemaExport;
  74 import org.hibernate.tool.hbm2ddl.SchemaExport.Type;
  75 import org.hibernate.tool.hbm2ddl.Target;
  76 import org.scannotation.AnnotationDB;
  77
  78
  79 /**
  80  * Goal which extracts the hibernate-mapping-configuration and
  81  * exports an according SQL-database-schema.
  82  *
  83  * @goal export
  84  * @phase process-classes
  85  * @threadSafe
  86  * @requiresDependencyResolution runtime
  87  */
  88 public class Hbm2DdlMojo extends AbstractMojo
  89 {
  90   public final static String EXPORT_SKIPPED_PROPERTY = "hibernate.export.skipped";
  91
  92   public final static String DRIVER_CLASS = "hibernate.connection.driver_class";
  93   public final static String URL = "hibernate.connection.url";
  94   public final static String USERNAME = "hibernate.connection.username";
  95   public final static String PASSWORD = "hibernate.connection.password";
  96   public final static String DIALECT = "hibernate.dialect";
  97   public final static String NAMING_STRATEGY="hibernate.ejb.naming_strategy";
  98   public final static String ENVERS = "hibernate.export.envers";
  99
 100   public final static String JPA_DRIVER = "javax.persistence.jdbc.driver";
 101   public final static String JPA_URL = "javax.persistence.jdbc.url";
 102   public final static String JPA_USERNAME = "javax.persistence.jdbc.user";
 103   public final static String JPA_PASSWORD = "javax.persistence.jdbc.password";
 104
 105   public final static String MD5S = "hibernate4-generatedschema.md5s";
 106
 107   private final static Pattern split = Pattern.compile("[^,\\s]+");
 108
 109
 110   /**
 111    * The maven project.
 112    * <p>
 113    * Only needed internally.
 114    *
 115    * @parameter property="project"
 116    * @required
 117    * @readonly
 118    */
 119   private MavenProject project;
 120
 121   /**
 122    * Build-directory.
 123    * <p>
 124    * Only needed internally.
 125    *
 126    * @parameter property="project.build.directory"
 127    * @required
 128    * @readonly
 129    */
 130   private String buildDirectory;
 131
 132   /**
 133    * Classes-Directory to scan.
 134    * <p>
 135    * This parameter defaults to the maven build-output-directory for classes.
 136    * Additionally, all dependencies are scanned for annotated classes.
 137    *
 138    * @parameter property="project.build.outputDirectory"
 139    * @since 1.0
 140    */
 141   private String outputDirectory;
 142
 143   /**
 144    * Whether to scan test-classes too, or not.
 145    * <p>
 146    * If this parameter is set to <code>true</code> the test-classes of the
 147    * artifact will be scanned for hibernate-annotated classes additionally.
 148    *
 149    * @parameter property="hibernate.export.scan_testclasses" default-value="false"
 150    * @since 1.0.1
 151    */
 152   private boolean scanTestClasses;
 153
 154   /**
 155    * Dependency-Scopes, that should be scanned for annotated classes.
 156    * <p>
 157    * By default, only dependencies in the scope <code>compile</code> are
 158    * scanned for annotated classes. Multiple scopes can be seperated by
 159    * white space or commas.
 160    * <p>
 161    * If you do not want any dependencies to be scanned for annotated
 162    * classes, set this parameter to <code>none</code>.
 163    * <p>
 164    * The plugin does not scan for annotated classes in transitive
 165    * dependencies. If some of your annotated classes are hidden in a
 166    * transitive dependency, you can simply add that dependency explicitly.
 167    *
 168    * @parameter property="hibernate.export.scan_dependencies" default-value="compile"
 169    * @since 1.0.3
 170    */
 171   private String scanDependencies;
 172
 173   /**
 174    * Test-Classes-Directory to scan.
 175    * <p>
 176    * This parameter defaults to the maven build-output-directory for
 177    * test-classes.
 178    * <p>
 179    * This parameter is only used, when <code>scanTestClasses</code> is set
 180    * to <code>true</code>!
 181    *
 182    * @parameter property="project.build.testOutputDirectory"
 183    * @since 1.0.2
 184    */
 185   private String testOutputDirectory;
 186
 187   /**
 188    * Skip execution
 189    * <p>
 190    * If set to <code>true</code>, the execution is skipped.
 191    * <p>
 192    * A skipped execution is signaled via the maven-property
 193    * <code>${hibernate.export.skipped}</code>.
 194    * <p>
 195    * The execution is skipped automatically, if no modified or newly added
 196    * annotated classes are found and the dialect was not changed.
 197    *
 198    * @parameter property="hibernate.skip" default-value="${maven.test.skip}"
 199    * @since 1.0
 200    */
 201   private boolean skip;
 202
 203   /**
 204    * Force execution
 205    * <p>
 206    * Force execution, even if no modified or newly added annotated classes
 207    * where found and the dialect was not changed.
 208    * <p>
 209    * <code>skip</code> takes precedence over <code>force</code>.
 210    *
 211    * @parameter property="hibernate.export.force" default-value="false"
 212    * @since 1.0
 213    */
 214   private boolean force;
 215
 216   /**
 217    * SQL-Driver name.
 218    *
 219    * @parameter property="hibernate.connection.driver_class"
 220    * @since 1.0
 221    */
 222   private String driverClassName;
 223
 224   /**
 225    * Database URL.
 226    *
 227    * @parameter property="hibernate.connection.url"
 228    * @since 1.0
 229    */
 230   private String url;
 231
 232   /**
 233    * Database username
 234    *
 235    * @parameter property="hibernate.connection.username"
 236    * @since 1.0
 237    */
 238   private String username;
 239
 240   /**
 241    * Database password
 242    *
 243    * @parameter property="hibernate.connection.password"
 244    * @since 1.0
 245    */
 246   private String password;
 247
 248   /**
 249    * Hibernate dialect.
 250    *
 251    * @parameter property="hibernate.dialect"
 252    * @since 1.0
 253    */
 254   private String hibernateDialect;
 255
 256   /**
 257    * Hibernate Naming Strategy
 258    *
 259    * @parameter property="hibernate.ejb.naming_strategy"
 260    * @since 1.0.2
 261    */
 262   private String hibernateNamingStrategy;
 263
 264   /**
 265    * Path to Hibernate properties file.
 266    * If this parameter is not set the plugin will try to load the configuration
 267    * from a file <code>hibernate.properties</code> on the classpath. The
 268    * test-classpath takes precedence.
 269    *
 270    * @parameter
 271    * @since 1.0
 272    */
 273   private String hibernateProperties;
 274
 275   /**
 276    * Path to Hibernate configuration file (.cfg.xml).
 277    * Settings in this file will overwrite settings in the properties file.
 278    * If this parameter is not set the plugin will try to load the configuration
 279    * from a file <code>hibernate.cfg.xml</code> on the classpath. The
 280    * test-classpath takes precedence.
 281    *
 282    * @parameter
 283    * @since 1.1.0
 284    */
 285   private String hibernateConfig;
 286
 287   /**
 288    * Name of the persistence-unit.
 289    * If there is only one persistence-unit available, that unit will be used
 290    * automatically.
 291    * Settings in this file will overwrite settings in the properties or the
 292    * configuration file.
 293    *
 294    * @parameter
 295    * @since 1.1.0
 296    */
 297   private String persistenceUnit;
 298
 299   /**
 300    * List of Hibernate-Mapping-Files (XML).
 301    * Multiple files can be separated with white-spaces and/or commas.
 302    *
 303    * @parameter property="hibernate.mapping"
 304    * @since 1.0.2
 305    */
 306   private String hibernateMapping;
 307
 308   /**
 309    * Target of execution:
 310    * <ul>
 311    *   <li><strong>NONE</strong> only export schema to SQL-script (forces execution, signals skip)</li>
 312    *   <li><strong>EXPORT</strong> create database (<strong>DEFAULT!</strong>). forces execution, signals skip)</li>
 313    *   <li><strong>SCRIPT</strong> export schema to SQL-script and print it to STDOUT</li>
 314    *   <li><strong>BOTH</strong></li>
 315    * </ul>
 316    *
 317    * A database connection is only needed for EXPORT and BOTH, but a
 318    * Hibernate-Dialect must always be chosen.
 319    *
 320    * @parameter property="hibernate.export.target" default-value="EXPORT"
 321    * @since 1.0
 322    */
 323   private String target;
 324
 325   /**
 326    * Type of execution.
 327    * <ul>
 328    *   <li><strong>NONE</strong> do nothing - just validate the configuration</li>
 329    *   <li><strong>CREATE</strong> create database-schema</li>
 330    *   <li><strong>DROP</strong> drop database-schema</li>
 331    *   <li><strong>BOTH</strong> (<strong>DEFAULT!</strong>)</li>
 332    * </ul>
 333    *
 334    * If NONE is choosen, no databaseconnection is needed.
 335    *
 336    * @parameter property="hibernate.export.type" default-value="BOTH"
 337    * @since 1.0
 338    */
 339   private String type;
 340
 341   /**
 342    * Output file.
 343    *
 344    * @parameter property="hibernate.export.schema.filename" default-value="${project.build.directory}/schema.sql"
 345    * @since 1.0
 346    */
 347   private String outputFile;
 348
 349   /**
 350    * Delimiter in output-file.
 351    *
 352    * @parameter property="hibernate.export.schema.delimiter" default-value=";"
 353    * @since 1.0
 354    */
 355   private String delimiter;
 356
 357   /**
 358    * Format output-file.
 359    *
 360    * @parameter property="hibernate.export.schema.format" default-value="true"
 361    * @since 1.0
 362    */
 363   private boolean format;
 364
 365   /**
 366    * Generate envers schema for auditing tables.
 367    *
 368    * @parameter property="hibernate.export.envers" default-value="true"
 369    * @since 1.0.3
 370    */
 371   private boolean envers;
 372
 373
 374   @Override
 375   public void execute()
 376     throws
 377       MojoFailureException,
 378       MojoExecutionException
 379   {
 380     if (skip)
 381     {
 382       getLog().info("Execution of hibernate4-maven-plugin:export was skipped!");
 383       project.getProperties().setProperty(EXPORT_SKIPPED_PROPERTY, "true");
 384       return;
 385     }
 386
 387     Map<String,String> md5s;
 388     boolean modified = false;
 389     File saved = new File(buildDirectory + File.separator + MD5S);
 390
 391     if (saved.isFile() && saved.length() > 0)
 392     {
 393       try
 394       {
 395         FileInputStream fis = new FileInputStream(saved);
 396         ObjectInputStream ois = new ObjectInputStream(fis);
 397         md5s = (HashMap<String,String>)ois.readObject();
 398         ois.close();
 399       }
 400       catch (Exception e)
 401       {
 402         md5s = new HashMap<String,String>();
 403         getLog().warn("Cannot read timestamps from saved: " + e);
 404       }
 405     }
 406     else
 407     {
 408       md5s = new HashMap<String,String>();
 409       try
 410       {
 411         saved.createNewFile();
 412       }
 413       catch (IOException e)
 414       {
 415         getLog().debug("Cannot create file \"" + saved.getPath() + "\" for timestamps: " + e);
 416       }
 417     }
 418
 419     URLClassLoader classLoader = null;
 420     try
 421     {
 422       getLog().debug("Creating ClassLoader for project-dependencies...");
 423       List<String> classpathFiles = project.getCompileClasspathElements();
 424       if (scanTestClasses)
 425         classpathFiles.addAll(project.getTestClasspathElements());
 426       List<URL> urls = new LinkedList<URL>();
 427       File file;
 428       file = new File(testOutputDirectory);
 429       if (!file.exists())
 430       {
 431         getLog().info("creating test-output-directory: " + testOutputDirectory);
 432         file.mkdirs();
 433       }
 434       urls.add(file.toURI().toURL());
 435       file = new File(outputDirectory);
 436       if (!file.exists())
 437       {
 438         getLog().info("creating output-directory: " + outputDirectory);
 439         file.mkdirs();
 440       }
 441       urls.add(file.toURI().toURL());
 442       for (String pathElement : classpathFiles)
 443       {
 444         getLog().debug("Dependency: " + pathElement);
 445         urls.add(new File(pathElement).toURI().toURL());
 446       }
 447       classLoader =
 448           new URLClassLoader(
 449               urls.toArray(new URL[urls.size()]),
 450               getClass().getClassLoader()
 451               );
 452     }
 453     catch (Exception e)
 454     {
 455       getLog().error("Error while creating ClassLoader!", e);
 456       throw new MojoExecutionException(e.getMessage());
 457     }
 458
 459     Set<Class<?>> classes =
 460         new TreeSet<Class<?>>(
 461             new Comparator<Class<?>>() {
 462               @Override
 463               public int compare(Class<?> a, Class<?> b)
 464               {
 465                 return a.getName().compareTo(b.getName());
 466               }
 467             }
 468           );
 469
 470     try
 471     {
 472       AnnotationDB db = new AnnotationDB();
 473       File dir = new File(outputDirectory);
 474       if (dir.exists())
 475       {
 476         getLog().info("Scanning directory " + outputDirectory + " for annotated classes...");
 477         URL dirUrl = dir.toURI().toURL();
 478         db.scanArchives(dirUrl);
 479       }
 480       if (scanTestClasses)
 481       {
 482         dir = new File(testOutputDirectory);
 483         if (dir.exists())
 484         {
 485           getLog().info("Scanning directory " + testOutputDirectory + " for annotated classes...");
 486           URL dirUrl = dir.toURI().toURL();
 487           db.scanArchives(dirUrl);
 488         }
 489       }
 490       if (scanDependencies != null)
 491       {
 492         Matcher matcher = split.matcher(scanDependencies);
 493         while (matcher.find())
 494         {
 495           getLog().info("Scanning dependencies for scope " + matcher.group());
 496           for (Artifact artifact : project.getDependencyArtifacts())
 497           {
 498             if (!artifact.getScope().equalsIgnoreCase(matcher.group()))
 499               continue;
 500             if (artifact.getFile() == null)
 501             {
 502               getLog().warn(
 503                   "Cannot scan dependency " +
 504                   artifact.getId() +
 505                   ": no JAR-file available!"
 506                   );
 507               continue;
 508             }
 509             getLog().info(
 510                 "Scanning dependency " +
 511                 artifact.getId() +
 512                 " for annotated classes..."
 513                 );
 514             db.scanArchives(artifact.getFile().toURI().toURL());
 515           }
 516         }
 517       }
 518
 519       Set<String> classNames = new HashSet<String>();
 520       if (db.getAnnotationIndex().containsKey(Entity.class.getName()))
 521         classNames.addAll(db.getAnnotationIndex().get(Entity.class.getName()));
 522       if (db.getAnnotationIndex().containsKey(MappedSuperclass.class.getName()))
 523         classNames.addAll(db.getAnnotationIndex().get(MappedSuperclass.class.getName()));
 524       if (db.getAnnotationIndex().containsKey(Embeddable.class.getName()))
 525         classNames.addAll(db.getAnnotationIndex().get(Embeddable.class.getName()));
 526
 527       MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
 528       for (String name : classNames)
 529       {
 530         Class<?> annotatedClass = classLoader.loadClass(name);
 531         classes.add(annotatedClass);
 532         String resourceName = annotatedClass.getName();
 533         resourceName = resourceName.substring(resourceName.lastIndexOf(".") + 1, resourceName.length()) + ".class";
 534         InputStream is =
 535             annotatedClass
 536                 .getResourceAsStream(resourceName);
 537         byte[] buffer = new byte[1024*4]; // copy data in 4MB-chunks
 538         int i;
 539         while((i = is.read(buffer)) > -1)
 540           digest.update(buffer, 0, i);
 541         is.close();
 542         byte[] bytes = digest.digest();
 543         BigInteger bi = new BigInteger(1, bytes);
 544         String newMd5 = String.format("%0" + (bytes.length << 1) + "x", bi);
 545         String oldMd5 = !md5s.containsKey(name) ? "" : md5s.get(name);
 546         if (!newMd5.equals(oldMd5))
 547         {
 548           getLog().debug("Found new or modified annotated class: " + name);
 549           modified = true;
 550           md5s.put(name, newMd5);
 551         }
 552         else
 553         {
 554           getLog().debug(oldMd5 + " -> class unchanged: " + name);
 555         }
 556       }
 557     }
 558     catch (ClassNotFoundException e)
 559     {
 560       getLog().error("Error while adding annotated classes!", e);
 561       throw new MojoExecutionException(e.getMessage());
 562     }
 563     catch (Exception e)
 564     {
 565       getLog().error("Error while scanning!", e);
 566       throw new MojoFailureException(e.getMessage());
 567     }
 568
 569
 570     ValidationConfiguration config = new ValidationConfiguration();
 571     // Clear unused system-properties
 572     config.setProperties(new Properties());
 573
 574
 575     ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
 576     StandardServiceRegistryImpl registry = null;
 577     MavenLogAppender.startPluginLog(this);
 578
 579     try
 580     {
 581       /**
 582        * Change class-loader of current thread, so that hibernate can
 583        * see all dependencies!
 584        */
 585       Thread.currentThread().setContextClassLoader(classLoader);
 586
 587
 588       /** Try to read configuration from properties-file */
 589       try
 590       {
 591         if (hibernateProperties == null)
 592         {
 593           URL url = classLoader.findResource("hibernate.properties");
 594           if (url == null)
 595           {
 596             getLog().info("No hibernate.properties on the classpath!");
 597           }
 598           else
 599           {
 600             getLog().info("Reading settings from hibernate.properties on the classpath.");
 601             Properties properties = new Properties();
 602             properties.load(url.openStream());
 603             config.setProperties(properties);
 604           }
 605         }
 606         else
 607         {
 608           File file = new File(hibernateProperties);
 609           if (file.exists())
 610           {
 611             getLog().info("Reading settings from file " + hibernateProperties + "...");
 612             Properties properties = new Properties();
 613             properties.load(new FileInputStream(file));
 614             config.setProperties(properties);
 615           }
 616           else
 617             getLog().info("No hibernate-properties-file found! (Checked path: " + hibernateProperties + ")");
 618         }
 619       }
 620       catch (IOException e)
 621       {
 622         getLog().error("Error while reading properties!", e);
 623         throw new MojoExecutionException(e.getMessage());
 624       }
 625
 626       /** Try to read configuration from configuration-file */
 627       try
 628       {
 629         if (hibernateConfig == null)
 630         {
 631           URL url = classLoader.findResource("hibernate.cfg.xml");
 632           if (url == null)
 633           {
 634             getLog().info("No hibernate.cfg.xml on the classpath!");
 635           }
 636           else
 637           {
 638             getLog().info("Reading settings from hibernate.cfg.xml on the classpath.");
 639             config.configure(url);
 640           }
 641         }
 642         else
 643         {
 644           File file = new File(hibernateConfig);
 645           if (file.exists())
 646           {
 647             getLog().info("Reading configuration from file " + hibernateConfig + "...");
 648             config.configure(file);
 649           }
 650           else
 651             getLog().info("No hibernate-configuration-file found! (Checked path: " + hibernateConfig + ")");
 652         }
 653       }
 654       catch (Exception e)
 655       {
 656         getLog().error("Error while reading configuration!", e);
 657         throw new MojoExecutionException(e.getMessage());
 658       }
 659
 660       ParsedPersistenceXmlDescriptor persistenceUnitDescriptor =
 661           getPersistenceUnitDescriptor(
 662               persistenceUnit,
 663               config.getProperties(),
 664               new MavenProjectClassLoaderService(classLoader)
 665               );
 666       if (persistenceUnitDescriptor != null)
 667         config.setProperties(persistenceUnitDescriptor.getProperties());
 668
 669
 670       /** Overwrite values from properties-file or set, if given */
 671
 672       if (driverClassName != null)
 673       {
 674         if (config.getProperties().containsKey(DRIVER_CLASS))
 675           getLog().debug(
 676               "Overwriting property " +
 677               DRIVER_CLASS + "=" + config.getProperty(DRIVER_CLASS) +
 678               " with the value " + driverClassName
 679             );
 680         else
 681           getLog().debug("Using the value " + driverClassName);
 682         config.setProperty(DRIVER_CLASS, driverClassName);
 683       }
 684       if (config.getProperty(DRIVER_CLASS) == null)
 685       {
 686         String driver = config.getProperty(JPA_DRIVER);
 687         if (driver != null)
 688         {
 689           getLog().info(
 690               DRIVER_CLASS +
 691               " is not set. Borrow setting from " +
 692               JPA_DRIVER +
 693               ": " +
 694               driver);
 695           config.setProperty(DRIVER_CLASS, driver);
 696         }
 697       }
 698
 699       if (url != null)
 700       {
 701         if (config.getProperties().containsKey(URL))
 702           getLog().debug(
 703               "Overwriting property " +
 704               URL + "=" + config.getProperty(URL) +
 705               " with the value " + url
 706             );
 707         else
 708           getLog().debug("Using the value " + url);
 709         config.setProperty(URL, url);
 710       }
 711       if (config.getProperty(URL) == null)
 712       {
 713         String url = config.getProperty(JPA_URL);
 714         if (url != null)
 715         {
 716           getLog().info(
 717               URL +
 718               " is not set. Borrow setting from " +
 719               JPA_URL +
 720               ": " +
 721               url);
 722           config.setProperty(URL, url);
 723         }
 724       }
 725
 726       if (username != null)
 727       {
 728         if (config.getProperties().containsKey(USERNAME))
 729           getLog().debug(
 730               "Overwriting property " +
 731               USERNAME + "=" + config.getProperty(USERNAME) +
 732               " with the value " + username
 733             );
 734         else
 735           getLog().debug("Using the value " + username);
 736         config.setProperty(USERNAME, username);
 737       }
 738       if (config.getProperty(USERNAME) == null)
 739       {
 740         String username = config.getProperty(JPA_USERNAME);
 741         if (username != null)
 742         {
 743           getLog().info(
 744               USERNAME +
 745               " is not set. Borrow setting from " +
 746               JPA_USERNAME +
 747               ": " +
 748               username);
 749           config.setProperty(USERNAME, username);
 750         }
 751       }
 752
 753       if (password != null)
 754       {
 755         if (config.getProperties().containsKey(PASSWORD))
 756           getLog().debug(
 757               "Overwriting property " +
 758               PASSWORD + "=" + config.getProperty(PASSWORD) +
 759               " with value " + password
 760             );
 761         else
 762           getLog().debug("Using value " + password + " for property " + PASSWORD);
 763         config.setProperty(PASSWORD, password);
 764       }
 765       if (config.getProperty(PASSWORD) == null)
 766       {
 767         String password = config.getProperty(JPA_PASSWORD);
 768         if (password != null)
 769         {
 770           getLog().info(
 771               PASSWORD +
 772               " is not set. Borrow setting from " +
 773               JPA_PASSWORD +
 774               ": " +
 775               password);
 776           config.setProperty(PASSWORD, password);
 777         }
 778       }
 779
 780       if (hibernateDialect != null)
 781       {
 782         if (config.getProperties().containsKey(DIALECT))
 783           getLog().debug(
 784               "Overwriting property " +
 785               DIALECT + "=" + config.getProperty(DIALECT) +
 786               " with value " + hibernateDialect
 787             );
 788         else
 789           getLog().debug(
 790               "Using value " + hibernateDialect + " for property " + DIALECT
 791               );
 792         config.setProperty(DIALECT, hibernateDialect);
 793       }
 794
 795       if ( hibernateNamingStrategy != null )
 796       {
 797         if ( config.getProperties().contains(NAMING_STRATEGY))
 798           getLog().debug(
 799               "Overwriting property " +
 800               NAMING_STRATEGY + "=" + config.getProperty(NAMING_STRATEGY) +
 801               " with value " + hibernateNamingStrategy
 802              );
 803         else
 804           getLog().debug(
 805               "Using value " + hibernateNamingStrategy + " for property " +
 806               NAMING_STRATEGY
 807               );
 808         config.setProperty(NAMING_STRATEGY, hibernateNamingStrategy);
 809       }
 810
 811       /** The generated SQL varies with the dialect! */
 812       if (md5s.containsKey(DIALECT))
 813       {
 814         String dialect = config.getProperty(DIALECT);
 815         if (md5s.get(DIALECT).equals(dialect))
 816           getLog().debug("SQL-dialect unchanged.");
 817         else
 818         {
 819           modified = true;
 820           if (dialect == null)
 821           {
 822             getLog().debug("SQL-dialect was unset.");
 823             md5s.remove(DIALECT);
 824           }
 825           else
 826           {
 827             getLog().debug("SQL-dialect changed: " + dialect);
 828             md5s.put(DIALECT, dialect);
 829           }
 830         }
 831       }
 832       else
 833       {
 834         String dialect = config.getProperty(DIALECT);
 835         if (dialect != null)
 836         {
 837           modified = true;
 838           md5s.put(DIALECT, config.getProperty(DIALECT));
 839         }
 840       }
 841
 842       /** The generated SQL varies with the envers-configuration */
 843       if (md5s.get(ENVERS) != null)
 844       {
 845         if (md5s.get(ENVERS).equals(Boolean.toString(envers)))
 846           getLog().debug("Envers-Configuration unchanged. Enabled: " + envers);
 847         else
 848         {
 849           getLog().debug("Envers-Configuration changed. Enabled: " + envers);
 850           modified = true;
 851           md5s.put(ENVERS, Boolean.toString(envers));
 852         }
 853       }
 854       else
 855       {
 856         modified = true;
 857         md5s.put(ENVERS, Boolean.toString(envers));
 858       }
 859
 860       if (config.getProperties().isEmpty())
 861       {
 862         getLog().error("No properties set!");
 863         throw new MojoFailureException("Hibernate configuration is missing!");
 864       }
 865
 866       getLog().info("Gathered hibernate-configuration (turn on debugging for details):");
 867       for (Entry<Object,Object> entry : config.getProperties().entrySet())
 868         getLog().info("  " + entry.getKey() + " = " + entry.getValue());
 869
 870
 871       getLog().debug("Adding explicitly configured mappings...");
 872       if (hibernateMapping != null)
 873       {
 874         try
 875         {
 876           MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
 877           for (String filename : hibernateMapping.split("[\\s,]+"))
 878           {
 879             // First try the filename as absolute/relative path
 880             File file = new File(filename);
 881             if (!file.exists())
 882             {
 883               // If the file was not found, search for it in the resource-directories
 884               for (Resource resource : project.getResources())
 885               {
 886                 file = new File(resource.getDirectory() + File.separator + filename);
 887                 if (file.exists())
 888                   break;
 889               }
 890             }
 891             if (file != null && file.exists())
 892             {
 893               InputStream is = new FileInputStream(file);
 894               byte[] buffer = new byte[1024*4]; // copy data in 4MB-chunks
 895               int i;
 896               while((i = is.read(buffer)) > -1)
 897                 digest.update(buffer, 0, i);
 898               is.close();
 899               byte[] bytes = digest.digest();
 900               BigInteger bi = new BigInteger(1, bytes);
 901               String newMd5 = String.format("%0" + (bytes.length << 1) + "x", bi);
 902               String oldMd5 = !md5s.containsKey(filename) ? "" : md5s.get(filename);
 903               if (!newMd5.equals(oldMd5))
 904               {
 905                 getLog().debug("Found new or modified mapping-file: " + filename);
 906                 modified = true;
 907                 md5s.put(filename, newMd5);
 908               }
 909               else
 910               {
 911                 getLog().debug(oldMd5 + " -> mapping-file unchanged: " + filename);
 912               }
 913               getLog().debug("Adding mappings from XML-configurationfile: " + file);
 914               config.addFile(file);
 915             }
 916             else
 917               throw new MojoFailureException("File " + filename + " could not be found in any of the configured resource-directories!");
 918           }
 919         }
 920         catch (NoSuchAlgorithmException e)
 921         {
 922           throw new MojoFailureException("Cannot calculate MD5 sums!", e);
 923         }
 924         catch (FileNotFoundException e)
 925         {
 926           throw new MojoFailureException("Cannot calculate MD5 sums!", e);
 927         }
 928         catch (IOException e)
 929         {
 930           throw new MojoFailureException("Cannot calculate MD5 sums!", e);
 931         }
 932       }
 933
 934       getLog().debug("Adding annotated classes to hibernate-mapping-configuration...");
 935       // build annotated packages
 936       Set<String> packages = new HashSet<String>();
 937       for (Class<?> annotatedClass : classes)
 938       {
 939         String packageName = annotatedClass.getPackage().getName();
 940         if (!packages.contains(packageName))
 941         {
 942           getLog().debug("Add package " + packageName);
 943           packages.add(packageName);
 944           config.addPackage(packageName);
 945           getLog().debug("type definintions" + config.getTypeDefs());
 946         }
 947         getLog().debug("Class " + annotatedClass);
 948         config.addAnnotatedClass(annotatedClass);
 949       }
 950
 951       Target target = null;
 952       try
 953       {
 954         target = Target.valueOf(this.target.toUpperCase());
 955       }
 956       catch (IllegalArgumentException e)
 957       {
 958         getLog().error("Invalid value for configuration-option \"target\": " + this.target);
 959         getLog().error("Valid values are: NONE, SCRIPT, EXPORT, BOTH");
 960         throw new MojoExecutionException("Invalid value for configuration-option \"target\"");
 961       }
 962       Type type = null;
 963       try
 964       {
 965         type = Type.valueOf(this.type.toUpperCase());
 966       }
 967       catch (IllegalArgumentException e)
 968       {
 969         getLog().error("Invalid value for configuration-option \"type\": " + this.type);
 970         getLog().error("Valid values are: NONE, CREATE, DROP, BOTH");
 971         throw new MojoExecutionException("Invalid value for configuration-option \"type\"");
 972       }
 973
 974
 975       if (config.getProperty(DIALECT) == null)
 976         throw new MojoFailureException("hibernate-dialect must be set!");
 977
 978
 979       if (target.equals(Target.SCRIPT) || target.equals(Target.NONE))
 980       {
 981         project.getProperties().setProperty(EXPORT_SKIPPED_PROPERTY, "true");
 982       }
 983       if (
 984           !modified
 985           && !target.equals(Target.SCRIPT)
 986           && !target.equals(Target.NONE)
 987           && !force
 988         )
 989       {
 990         getLog().info("No modified annotated classes or mapping-files found and dialect unchanged.");
 991         getLog().info("Skipping schema generation!");
 992         project.getProperties().setProperty(EXPORT_SKIPPED_PROPERTY, "true");
 993         return;
 994       }
 995
 996
 997       if ( config.getProperties().containsKey(NAMING_STRATEGY))
 998       {
 999         String namingStrategy = config.getProperty(NAMING_STRATEGY);
1000         getLog().debug("Explicitly set NamingStrategy: " + namingStrategy);
1001         try
1002         {
1003           @SuppressWarnings("unchecked")
1004           Class<NamingStrategy> namingStrategyClass = (Class<NamingStrategy>) Class.forName(namingStrategy);
1005           config.setNamingStrategy(namingStrategyClass.newInstance());
1006         }
1007         catch (Exception e)
1008         {
1009           getLog().error("Error setting NamingStrategy", e);
1010           throw new MojoExecutionException(e.getMessage());
1011         }
1012       }
1013
1014
1015       Environment.verifyProperties(config.getProperties());
1016       ConfigurationHelper.resolvePlaceHolders(config.getProperties());
1017       registry =
1018           (StandardServiceRegistryImpl)
1019           new StandardServiceRegistryBuilder()
1020               .applySettings(config.getProperties())
1021               .build();
1022
1023       config.buildMappings();
1024
1025       if (envers)
1026       {
1027         getLog().info("Automatic auditing via hibernate-envers enabled!");
1028         AuditConfiguration.getFor(config);
1029       }
1030
1031       SchemaExport export = new SchemaExport(registry, config);
1032       export.setDelimiter(delimiter);
1033       export.setFormat(format);
1034
1035       File outF = new File(outputFile);
1036
1037       if (!outF.isAbsolute())
1038       {
1039         // Interpret relative file path relative to build directory
1040         outF = new File(buildDirectory, outputFile);
1041         getLog().info("Adjusted relative path, resulting path is " + outF.getPath());
1042       }
1043
1044       // Ensure that directory path for specified file exists
1045       File outFileParentDir = outF.getParentFile();
1046       if (null != outFileParentDir && !outFileParentDir.exists())
1047       {
1048         try
1049         {
1050           getLog().info("Creating directory path for output file:" + outFileParentDir.getPath());
1051           outFileParentDir.mkdirs();
1052         }
1053         catch (Exception e)
1054         {
1055           getLog().error("Error creating directory path for output file: " + e.getLocalizedMessage());
1056         }
1057       }
1058
1059       export.setOutputFile(outF.getPath());
1060       export.execute(target, type);
1061
1062       for (Object exception : export.getExceptions())
1063         getLog().debug(exception.toString());
1064     }
1065     finally
1066     {
1067       /** Stop Log-Capturing */
1068       MavenLogAppender.endPluginLog(this);
1069
1070       /** Restore the old class-loader (TODO: is this really necessary?) */
1071       Thread.currentThread().setContextClassLoader(contextClassLoader);
1072
1073       if (registry != null)
1074         registry.destroy();
1075     }
1076
1077     /** Write md5-sums for annotated classes to file */
1078     try
1079     {
1080       FileOutputStream fos = new FileOutputStream(saved);
1081       ObjectOutputStream oos = new ObjectOutputStream(fos);
1082       oos.writeObject(md5s);
1083       oos.close();
1084       fos.close();
1085     }
1086     catch (Exception e)
1087     {
1088       getLog().error("Cannot write md5-sums to file: " + e);
1089     }
1090   }
1091
1092   private ParsedPersistenceXmlDescriptor getPersistenceUnitDescriptor(
1093       String name,
1094       Properties properties,
1095       ClassLoaderService loader
1096       )
1097       throws
1098         MojoFailureException
1099   {
1100     PersistenceXmlParser parser =
1101         new PersistenceXmlParser(
1102             loader,
1103             PersistenceUnitTransactionType.RESOURCE_LOCAL
1104              );
1105
1106     List<ParsedPersistenceXmlDescriptor> units = parser.doResolve(properties);
1107
1108     if (name == null)
1109     {
1110       switch (units.size())
1111       {
1112         case 0:
1113           getLog().info("Found no META-INF/persistence.xml.");
1114           return null;
1115         case 1:
1116           getLog().info("Using persistence-unit " + units.get(0).getName());
1117           return units.get(0);
1118         default:
1119           getLog().warn("No name provided and multiple persistence units found:");
1120           for (ParsedPersistenceXmlDescriptor unit : units)
1121             getLog().warn(" - " + unit.getName());
1122           return null;
1123       }
1124
1125     }
1126
1127     for (ParsedPersistenceXmlDescriptor unit : units)
1128     {
1129       getLog().debug("Found persistence-unit " + unit.getName());
1130       if (!unit.getName().equals(name))
1131         continue;
1132
1133       // See if we (Hibernate) are the persistence provider
1134       if (!ProviderChecker.isProvider(unit, properties))
1135       {
1136         getLog().debug("Wrong provider: " + unit.getProviderClassName());
1137         continue;
1138       }
1139
1140       getLog().info("Using persistence-unit " + unit.getName());
1141       return unit;
1142     }
1143
1144     throw new MojoFailureException("Could not find persistence-unit " + name);
1145   }
1146
1147
1148   static final class MavenProjectClassLoaderService implements ClassLoaderService
1149   {
1150     final private ClassLoader loader;
1151
1152
1153     public MavenProjectClassLoaderService(ClassLoader loader)
1154     {
1155       this.loader = loader;
1156     }
1157
1158
1159     @Override
1160     public <T> Class<T> classForName(String name)
1161     {
1162       try
1163       {
1164         return (Class<T>)loader.loadClass(name);
1165       }
1166       catch (ClassNotFoundException e)
1167       {
1168         throw new ClassLoadingException( "Unable to load class [" + name + "]", e );
1169       }
1170     }
1171
1172     @Override
1173     public URL locateResource(String name)
1174     {
1175       return loader.getResource(name);
1176     }
1177
1178     @Override
1179     public InputStream locateResourceStream(String name)
1180     {
1181       return loader.getResourceAsStream(name);
1182     }
1183
1184     @Override
1185     public List<URL> locateResources(String name)
1186     {
1187       try
1188       {
1189         return Collections.list(loader.getResources(name));
1190       }
1191       catch (IOException e)
1192       {
1193         return Collections.EMPTY_LIST;
1194       }
1195     }
1196
1197     @Override
1198     public <S> LinkedHashSet<S> loadJavaServices(Class<S> serviceContract)
1199     {
1200       throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
1201     }
1202
1203     @Override
1204     public void stop() { }
1205
1206   }
1207
1208
1209   /**
1210    * Needed, because DriverManager won't pick up drivers, that were not
1211    * loaded by the system-classloader!
1212    * See:
1213    * http://stackoverflow.com/questions/288828/how-to-use-a-jdbc-driver-fromodifiedm-an-arbitrary-location
1214    */
1215   static final class DriverProxy implements Driver
1216   {
1217     private final Driver target;
1218
1219     DriverProxy(Driver target)
1220     {
1221       if (target == null)
1222         throw new NullPointerException();
1223       this.target = target;
1224     }
1225
1226     public java.sql.Driver getTarget()
1227     {
1228       return target;
1229     }
1230
1231     @Override
1232     public boolean acceptsURL(String url) throws SQLException
1233     {
1234       return target.acceptsURL(url);
1235     }
1236
1237     @Override
1238     public java.sql.Connection connect(
1239         String url,
1240         java.util.Properties info
1241       )
1242       throws
1243         SQLException
1244     {
1245       return target.connect(url, info);
1246     }
1247
1248     @Override
1249     public int getMajorVersion()
1250     {
1251       return target.getMajorVersion();
1252     }
1253
1254     @Override
1255     public int getMinorVersion()
1256     {
1257       return target.getMinorVersion();
1258     }
1259
1260     @Override
1261     public DriverPropertyInfo[] getPropertyInfo(
1262         String url,
1263         Properties info
1264       )
1265       throws
1266         SQLException
1267     {
1268       return target.getPropertyInfo(url, info);
1269     }
1270
1271     @Override
1272     public boolean jdbcCompliant()
1273     {
1274       return target.jdbcCompliant();
1275     }
1276
1277     /**
1278      * This Method cannot be annotated with @Override, becaus the plugin
1279      * will not compile then under Java 1.6!
1280      */
1281     public Logger getParentLogger() throws SQLFeatureNotSupportedException
1282     {
1283       throw new SQLFeatureNotSupportedException("Not supported, for backward-compatibility with Java 1.6");
1284     }
1285
1286     @Override
1287     public String toString()
1288     {
1289       return "Proxy: " + target;
1290     }
1291
1292     @Override
1293     public int hashCode()
1294     {
1295       return target.hashCode();
1296     }
1297
1298     @Override
1299     public boolean equals(Object obj)
1300     {
1301       if (!(obj instanceof DriverProxy))
1302         return false;
1303       DriverProxy other = (DriverProxy) obj;
1304       return this.target.equals(other.target);
1305     }
1306   }
1307 }