juplo.de Git - hibernate4-maven-plugin/blob - src/main/java/de/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.Connection;
  34 import java.sql.Driver;
  35 import java.sql.DriverManager;
  36 import java.sql.DriverPropertyInfo;
  37 import java.sql.SQLException;
  38 import java.sql.SQLFeatureNotSupportedException;
  39 import java.util.Comparator;
  40 import java.util.Enumeration;
  41 import java.util.HashMap;
  42 import java.util.HashSet;
  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 org.apache.maven.artifact.Artifact;
  56 import org.apache.maven.model.Resource;
  57 import org.apache.maven.plugin.AbstractMojo;
  58 import org.apache.maven.plugin.MojoExecutionException;
  59 import org.apache.maven.plugin.MojoFailureException;
  60 import org.apache.maven.project.MavenProject;
  61 import org.hibernate.cfg.NamingStrategy;
  62 import org.hibernate.envers.configuration.spi.AuditConfiguration;
  63 import org.hibernate.tool.hbm2ddl.SchemaExport;
  64 import org.hibernate.tool.hbm2ddl.SchemaExport.Type;
  65 import org.hibernate.tool.hbm2ddl.Target;
  66 import org.scannotation.AnnotationDB;
  67
  68
  69 /**
  70  * Goal which extracts the hibernate-mapping-configuration and
  71  * exports an according SQL-database-schema.
  72  *
  73  * @goal export
  74  * @phase process-classes
  75  * @threadSafe
  76  * @requiresDependencyResolution runtime
  77  */
  78 public class Hbm2DdlMojo extends AbstractMojo
  79 {
  80   public final static String EXPORT_SKIPPED_PROPERTY = "hibernate.export.skipped";
  81
  82   public final static String DRIVER_CLASS = "hibernate.connection.driver_class";
  83   public final static String URL = "hibernate.connection.url";
  84   public final static String USERNAME = "hibernate.connection.username";
  85   public final static String PASSWORD = "hibernate.connection.password";
  86   public final static String DIALECT = "hibernate.dialect";
  87   public final static String NAMING_STRATEGY="hibernate.ejb.naming_strategy";
  88   public final static String ENVERS = "hibernate.export.envers";
  89
  90   public final static String MD5S = "hibernate4-generatedschema.md5s";
  91
  92   private final static Pattern split = Pattern.compile("[^,\\s]+");
  93
  94
  95   /**
  96    * The maven project.
  97    * <p>
  98    * Only needed internally.
  99    *
 100    * @parameter property="project"
 101    * @required
 102    * @readonly
 103    */
 104   private MavenProject project;
 105
 106   /**
 107    * Build-directory.
 108    * <p>
 109    * Only needed internally.
 110    *
 111    * @parameter property="project.build.directory"
 112    * @required
 113    * @readonly
 114    */
 115   private String buildDirectory;
 116
 117   /**
 118    * Classes-Directory to scan.
 119    * <p>
 120    * This parameter defaults to the maven build-output-directory for classes.
 121    * Additionally, all dependencies are scanned for annotated classes.
 122    *
 123    * @parameter property="project.build.outputDirectory"
 124    * @since 1.0
 125    */
 126   private String outputDirectory;
 127
 128   /**
 129    * Whether to scan test-classes too, or not.
 130    * <p>
 131    * If this parameter is set to <code>true</code> the test-classes of the
 132    * artifact will be scanned for hibernate-annotated classes additionally.
 133    *
 134    * @parameter property="hibernate.export.scan_testclasses" default-value="false"
 135    * @since 1.0.1
 136    */
 137   private boolean scanTestClasses;
 138
 139   /**
 140    * Dependency-Scopes, that should be scanned for annotated classes.
 141    * <p>
 142    * By default, only dependencies in the scope <code>compile</code> are
 143    * scanned for annotated classes. Multiple scopes can be seperated by
 144    * white space or commas.
 145    * <p>
 146    * The plugin does not scan for annotated classes in transitive
 147    * dependencies. If some of your annotated classes are hidden in a
 148    * transitive dependency, you can simply add that dependency explicitly.
 149    *
 150    * @parameter property="hibernate.export.scan_dependencies" default-value="compile"
 151    * @since 1.0.3
 152    */
 153   private String scanDependencies;
 154
 155   /**
 156    * Test-Classes-Directory to scan.
 157    * <p>
 158    * This parameter defaults to the maven build-output-directory for
 159    * test-classes.
 160    * <p>
 161    * This parameter is only used, when <code>scanTestClasses</code> is set
 162    * to <code>true</code>!
 163    *
 164    * @parameter property="project.build.testOutputDirectory"
 165    * @since 1.0.2
 166    */
 167   private String testOutputDirectory;
 168
 169   /**
 170    * Skip execution
 171    * <p>
 172    * If set to <code>true</code>, the execution is skipped.
 173    * <p>
 174    * A skipped execution is signaled via the maven-property
 175    * <code>${hibernate.export.skipped}</code>.
 176    * <p>
 177    * The execution is skipped automatically, if no modified or newly added
 178    * annotated classes are found and the dialect was not changed.
 179    *
 180    * @parameter property="hibernate.skip" default-value="${maven.test.skip}"
 181    * @since 1.0
 182    */
 183   private boolean skip;
 184
 185   /**
 186    * Force execution
 187    * <p>
 188    * Force execution, even if no modified or newly added annotated classes
 189    * where found and the dialect was not changed.
 190    * <p>
 191    * <code>skip</code> takes precedence over <code>force</code>.
 192    *
 193    * @parameter property="hibernate.export.force" default-value="false"
 194    * @since 1.0
 195    */
 196   private boolean force;
 197
 198   /**
 199    * SQL-Driver name.
 200    *
 201    * @parameter property="hibernate.connection.driver_class"
 202    * @since 1.0
 203    */
 204   private String driverClassName;
 205
 206   /**
 207    * Database URL.
 208    *
 209    * @parameter property="hibernate.connection.url"
 210    * @since 1.0
 211    */
 212   private String url;
 213
 214   /**
 215    * Database username
 216    *
 217    * @parameter property="hibernate.connection.username"
 218    * @since 1.0
 219    */
 220   private String username;
 221
 222   /**
 223    * Database password
 224    *
 225    * @parameter property="hibernate.connection.password"
 226    * @since 1.0
 227    */
 228   private String password;
 229
 230   /**
 231    * Hibernate dialect.
 232    *
 233    * @parameter property="hibernate.dialect"
 234    * @since 1.0
 235    */
 236   private String hibernateDialect;
 237
 238   /**
 239    * Hibernate Naming Strategy
 240    *
 241    * @parameter property="hibernate.ejb.naming_strategy"
 242    * @since 1.0.2
 243    */
 244   private String hibernateNamingStrategy;
 245
 246   /**
 247    * Path to Hibernate configuration file.
 248    *
 249    * @parameter default-value="${project.build.outputDirectory}/hibernate.properties"
 250    * @since 1.0
 251    */
 252   private String hibernateProperties;
 253
 254   /**
 255    * List of Hibernate-Mapping-Files (XML).
 256    * Multiple files can be separated with white-spaces and/or commas.
 257    *
 258    * @parameter property="hibernate.mapping"
 259    * @since 1.0.2
 260    */
 261   private String hibernateMapping;
 262
 263   /**
 264    * Target of execution:
 265    * <ul>
 266    *   <li><strong>NONE</strong> only export schema to SQL-script (forces execution, signals skip)</li>
 267    *   <li><strong>EXPORT</strong> create database (<strong>DEFAULT!</strong>). forces execution, signals skip)</li>
 268    *   <li><strong>SCRIPT</strong> export schema to SQL-script and print it to STDOUT</li>
 269    *   <li><strong>BOTH</strong></li>
 270    * </ul>
 271    *
 272    * A database connection is only needed for EXPORT and BOTH, but a
 273    * Hibernate-Dialect must always be chosen.
 274    *
 275    * @parameter property="hibernate.export.target" default-value="EXPORT"
 276    * @since 1.0
 277    */
 278   private String target;
 279
 280   /**
 281    * Type of execution.
 282    * <ul>
 283    *   <li><strong>NONE</strong> do nothing - just validate the configuration</li>
 284    *   <li><strong>CREATE</strong> create database-schema</li>
 285    *   <li><strong>DROP</strong> drop database-schema</li>
 286    *   <li><strong>BOTH</strong> (<strong>DEFAULT!</strong>)</li>
 287    * </ul>
 288    *
 289    * If NONE is choosen, no databaseconnection is needed.
 290    *
 291    * @parameter property="hibernate.export.type" default-value="BOTH"
 292    * @since 1.0
 293    */
 294   private String type;
 295
 296   /**
 297    * Output file.
 298    *
 299    * @parameter property="hibernate.export.schema.filename" default-value="${project.build.directory}/schema.sql"
 300    * @since 1.0
 301    */
 302   private String outputFile;
 303
 304   /**
 305    * Delimiter in output-file.
 306    *
 307    * @parameter property="hibernate.export.schema.delimiter" default-value=";"
 308    * @since 1.0
 309    */
 310   private String delimiter;
 311
 312   /**
 313    * Format output-file.
 314    *
 315    * @parameter property="hibernate.export.schema.format" default-value="true"
 316    * @since 1.0
 317    */
 318   private boolean format;
 319
 320   /**
 321    * Generate envers schema for auditing tables.
 322    *
 323    * @parameter property="hibernate.export.envers" default-value="false"
 324    * @since 1.0.3
 325    */
 326   private boolean envers;
 327
 328
 329   @Override
 330   public void execute()
 331     throws
 332       MojoFailureException,
 333       MojoExecutionException
 334   {
 335     if (skip)
 336     {
 337       getLog().info("Execution of hibernate4-maven-plugin:export was skipped!");
 338       project.getProperties().setProperty(EXPORT_SKIPPED_PROPERTY, "true");
 339       return;
 340     }
 341
 342     Map<String,String> md5s;
 343     boolean modified = false;
 344     File saved = new File(buildDirectory + File.separator + MD5S);
 345
 346     if (saved.isFile() && saved.length() > 0)
 347     {
 348       try
 349       {
 350         FileInputStream fis = new FileInputStream(saved);
 351         ObjectInputStream ois = new ObjectInputStream(fis);
 352         md5s = (HashMap<String,String>)ois.readObject();
 353         ois.close();
 354       }
 355       catch (Exception e)
 356       {
 357         md5s = new HashMap<String,String>();
 358         getLog().warn("Cannot read timestamps from saved: " + e);
 359       }
 360     }
 361     else
 362     {
 363       md5s = new HashMap<String,String>();
 364       try
 365       {
 366         saved.createNewFile();
 367       }
 368       catch (IOException e)
 369       {
 370         getLog().debug("Cannot create file \"" + saved.getPath() + "\" for timestamps: " + e);
 371       }
 372     }
 373
 374     ClassLoader classLoader = null;
 375     try
 376     {
 377       getLog().debug("Creating ClassLoader for project-dependencies...");
 378       List<String> classpathFiles = project.getCompileClasspathElements();
 379       if (scanTestClasses)
 380         classpathFiles.addAll(project.getTestClasspathElements());
 381       URL[] urls = new URL[classpathFiles.size()];
 382       for (int i = 0; i < classpathFiles.size(); ++i)
 383       {
 384         getLog().debug("Dependency: " + classpathFiles.get(i));
 385         urls[i] = new File(classpathFiles.get(i)).toURI().toURL();
 386       }
 387       classLoader = new URLClassLoader(urls, getClass().getClassLoader());
 388     }
 389     catch (Exception e)
 390     {
 391       getLog().error("Error while creating ClassLoader!", e);
 392       throw new MojoExecutionException(e.getMessage());
 393     }
 394
 395     Set<Class<?>> classes =
 396         new TreeSet<Class<?>>(
 397             new Comparator<Class<?>>() {
 398               @Override
 399               public int compare(Class<?> a, Class<?> b)
 400               {
 401                 return a.getName().compareTo(b.getName());
 402               }
 403             }
 404           );
 405
 406     try
 407     {
 408       AnnotationDB db = new AnnotationDB();
 409       File dir = new File(outputDirectory);
 410       if (dir.exists())
 411       {
 412         getLog().info("Scanning directory " + outputDirectory + " for annotated classes...");
 413         URL dirUrl = dir.toURI().toURL();
 414         db.scanArchives(dirUrl);
 415       }
 416       if (scanTestClasses)
 417       {
 418         dir = new File(testOutputDirectory);
 419         if (dir.exists())
 420         {
 421           getLog().info("Scanning directory " + testOutputDirectory + " for annotated classes...");
 422           URL dirUrl = dir.toURI().toURL();
 423           db.scanArchives(dirUrl);
 424         }
 425       }
 426       if (scanDependencies != null)
 427       {
 428         Matcher matcher = split.matcher(scanDependencies);
 429         while (matcher.find())
 430         {
 431           getLog().info("Scanning dependencies for scope " + matcher.group());
 432           for (Artifact artifact : project.getDependencyArtifacts())
 433           {
 434             if (!artifact.getScope().equalsIgnoreCase(matcher.group()))
 435               continue;
 436             if (artifact.getFile() == null)
 437             {
 438               getLog().warn(
 439                   "Cannot scan dependency " +
 440                   artifact.getId() +
 441                   ": no JAR-file available!"
 442                   );
 443               continue;
 444             }
 445             getLog().info(
 446                 "Scanning dependency " +
 447                 artifact.getId() +
 448                 " for annotated classes..."
 449                 );
 450             db.scanArchives(artifact.getFile().toURI().toURL());
 451           }
 452         }
 453       }
 454
 455       Set<String> classNames = new HashSet<String>();
 456       if (db.getAnnotationIndex().containsKey(Entity.class.getName()))
 457         classNames.addAll(db.getAnnotationIndex().get(Entity.class.getName()));
 458       if (db.getAnnotationIndex().containsKey(MappedSuperclass.class.getName()))
 459         classNames.addAll(db.getAnnotationIndex().get(MappedSuperclass.class.getName()));
 460       if (db.getAnnotationIndex().containsKey(Embeddable.class.getName()))
 461         classNames.addAll(db.getAnnotationIndex().get(Embeddable.class.getName()));
 462
 463       MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
 464       for (String name : classNames)
 465       {
 466         Class<?> annotatedClass = classLoader.loadClass(name);
 467         classes.add(annotatedClass);
 468         String resourceName = annotatedClass.getName();
 469         resourceName = resourceName.substring(resourceName.lastIndexOf(".") + 1, resourceName.length()) + ".class";
 470         InputStream is =
 471             annotatedClass
 472                 .getResourceAsStream(resourceName);
 473         byte[] buffer = new byte[1024*4]; // copy data in 4MB-chunks
 474         int i;
 475         while((i = is.read(buffer)) > -1)
 476           digest.update(buffer, 0, i);
 477         is.close();
 478         byte[] bytes = digest.digest();
 479         BigInteger bi = new BigInteger(1, bytes);
 480         String newMd5 = String.format("%0" + (bytes.length << 1) + "x", bi);
 481         String oldMd5 = !md5s.containsKey(name) ? "" : md5s.get(name);
 482         if (!newMd5.equals(oldMd5))
 483         {
 484           getLog().debug("Found new or modified annotated class: " + name);
 485           modified = true;
 486           md5s.put(name, newMd5);
 487         }
 488         else
 489         {
 490           getLog().debug(oldMd5 + " -> class unchanged: " + name);
 491         }
 492       }
 493     }
 494     catch (ClassNotFoundException e)
 495     {
 496       getLog().error("Error while adding annotated classes!", e);
 497       throw new MojoExecutionException(e.getMessage());
 498     }
 499     catch (Exception e)
 500     {
 501       getLog().error("Error while scanning!", e);
 502       throw new MojoFailureException(e.getMessage());
 503     }
 504
 505     if (classes.isEmpty())
 506     {
 507       if (hibernateMapping == null || hibernateMapping.isEmpty())
 508         throw new MojoFailureException("No annotated classes found in directory " + outputDirectory);
 509     }
 510     else
 511     {
 512       getLog().debug("Detected classes with mapping-annotations:");
 513       for (Class<?> annotatedClass : classes)
 514         getLog().debug("  " + annotatedClass.getName());
 515     }
 516
 517
 518     Properties properties = new Properties();
 519
 520     /** Try to read configuration from properties-file */
 521     try
 522     {
 523       File file = new File(hibernateProperties);
 524       if (file.exists())
 525       {
 526         getLog().info("Reading properties from file " + hibernateProperties + "...");
 527         properties.load(new FileInputStream(file));
 528       }
 529       else
 530         getLog().info("No hibernate-properties-file found! (Checked path: " + hibernateProperties + ")");
 531     }
 532     catch (IOException e)
 533     {
 534       getLog().error("Error while reading properties!", e);
 535       throw new MojoExecutionException(e.getMessage());
 536     }
 537
 538     /** Overwrite values from properties-file or set, if given */
 539     if (driverClassName != null)
 540     {
 541       if (properties.containsKey(DRIVER_CLASS))
 542         getLog().debug(
 543             "Overwriting property " +
 544             DRIVER_CLASS + "=" + properties.getProperty(DRIVER_CLASS) +
 545             " with the value " + driverClassName
 546           );
 547       else
 548         getLog().debug("Using the value " + driverClassName);
 549       properties.setProperty(DRIVER_CLASS, driverClassName);
 550     }
 551     if (url != null)
 552     {
 553       if (properties.containsKey(URL))
 554         getLog().debug(
 555             "Overwriting property " +
 556             URL + "=" + properties.getProperty(URL) +
 557             " with the value " + url
 558           );
 559       else
 560         getLog().debug("Using the value " + url);
 561       properties.setProperty(URL, url);
 562     }
 563     if (username != null)
 564     {
 565       if (properties.containsKey(USERNAME))
 566         getLog().debug(
 567             "Overwriting property " +
 568             USERNAME + "=" + properties.getProperty(USERNAME) +
 569             " with the value " + username
 570           );
 571       else
 572         getLog().debug("Using the value " + username);
 573       properties.setProperty(USERNAME, username);
 574     }
 575     if (password != null)
 576     {
 577       if (properties.containsKey(PASSWORD))
 578         getLog().debug(
 579             "Overwriting property " +
 580             PASSWORD + "=" + properties.getProperty(PASSWORD) +
 581             " with value " + password
 582           );
 583       else
 584         getLog().debug("Using value " + password + " for property " + PASSWORD);
 585       properties.setProperty(PASSWORD, password);
 586     }
 587     if (hibernateDialect != null)
 588     {
 589       if (properties.containsKey(DIALECT))
 590         getLog().debug(
 591             "Overwriting property " +
 592             DIALECT + "=" + properties.getProperty(DIALECT) +
 593             " with value " + hibernateDialect
 594           );
 595       else
 596         getLog().debug(
 597             "Using value " + hibernateDialect + " for property " + DIALECT
 598             );
 599       properties.setProperty(DIALECT, hibernateDialect);
 600     }
 601     else
 602     {
 603       hibernateDialect = properties.getProperty(DIALECT);
 604     }
 605     if ( hibernateNamingStrategy != null )
 606     {
 607       if ( properties.contains(NAMING_STRATEGY))
 608         getLog().debug(
 609             "Overwriting property " +
 610             NAMING_STRATEGY + "=" + properties.getProperty(NAMING_STRATEGY) +
 611             " with value " + hibernateNamingStrategy
 612            );
 613       else
 614         getLog().debug(
 615             "Using value " + hibernateNamingStrategy + " for property " +
 616             NAMING_STRATEGY
 617             );
 618       properties.setProperty(NAMING_STRATEGY, hibernateNamingStrategy);
 619     }
 620
 621     /** The generated SQL varies with the dialect! */
 622     if (md5s.containsKey(DIALECT))
 623     {
 624       String dialect = properties.getProperty(DIALECT);
 625       if (md5s.get(DIALECT).equals(dialect))
 626         getLog().debug("SQL-dialect unchanged.");
 627       else
 628       {
 629         modified = true;
 630         if (dialect == null)
 631         {
 632           getLog().debug("SQL-dialect was unset.");
 633           md5s.remove(DIALECT);
 634         }
 635         else
 636         {
 637           getLog().debug("SQL-dialect changed: " + dialect);
 638           md5s.put(DIALECT, dialect);
 639         }
 640       }
 641     }
 642     else
 643     {
 644       String dialect = properties.getProperty(DIALECT);
 645       if (dialect != null)
 646       {
 647         modified = true;
 648         md5s.put(DIALECT, properties.getProperty(DIALECT));
 649       }
 650     }
 651
 652     /** The generated SQL varies with the envers-configuration */
 653     if (md5s.get(ENVERS) != null)
 654     {
 655       if (md5s.get(ENVERS).equals(Boolean.toString(envers)))
 656         getLog().debug("Envers-Configuration unchanged. Enabled: " + envers);
 657       else
 658       {
 659         getLog().debug("Envers-Configuration changed. Enabled: " + envers);
 660         modified = true;
 661         md5s.put(ENVERS, Boolean.toString(envers));
 662       }
 663     }
 664     else
 665     {
 666       modified = true;
 667       md5s.put(ENVERS, Boolean.toString(envers));
 668     }
 669
 670     if (properties.isEmpty())
 671     {
 672       getLog().error("No properties set!");
 673       throw new MojoFailureException("Hibernate configuration is missing!");
 674     }
 675
 676     final ValidationConfiguration config = new ValidationConfiguration(hibernateDialect);
 677
 678     config.setProperties(properties);
 679
 680     if ( properties.containsKey(NAMING_STRATEGY))
 681     {
 682       String namingStrategy = properties.getProperty(NAMING_STRATEGY);
 683       getLog().debug("Explicitly set NamingStrategy: " + namingStrategy);
 684       try
 685       {
 686         @SuppressWarnings("unchecked")
 687         Class<NamingStrategy> namingStrategyClass = (Class<NamingStrategy>) Class.forName(namingStrategy);
 688         config.setNamingStrategy(namingStrategyClass.newInstance());
 689       }
 690       catch (Exception e)
 691       {
 692         getLog().error("Error setting NamingStrategy", e);
 693         throw new MojoExecutionException(e.getMessage());
 694       }
 695     }
 696
 697     ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
 698     Connection connection = null;
 699     MavenLogAppender.startPluginLog(this);
 700     try
 701     {
 702       /**
 703        * Change class-loader of current thread, so that hibernate can
 704        * see all dependencies!
 705        */
 706       Thread.currentThread().setContextClassLoader(classLoader);
 707
 708       getLog().debug("Adding annotated classes to hibernate-mapping-configuration...");
 709       // build annotated packages
 710       Set<String> packages = new HashSet<String>();
 711       for (Class<?> annotatedClass : classes)
 712       {
 713         String packageName = annotatedClass.getPackage().getName();
 714         if (!packages.contains(packageName))
 715         {
 716           getLog().debug("Add package " + packageName);
 717           packages.add(packageName);
 718           config.addPackage(packageName);
 719           getLog().debug("type definintions" + config.getTypeDefs());
 720         }
 721         getLog().debug("Class " + annotatedClass);
 722         config.addAnnotatedClass(annotatedClass);
 723       }
 724
 725       if (hibernateMapping != null)
 726       {
 727         try
 728         {
 729           MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
 730           for (String filename : hibernateMapping.split("[\\s,]+"))
 731           {
 732             // First try the filename as absolute/relative path
 733             File file = new File(filename);
 734             if (!file.exists())
 735             {
 736               // If the file was not found, search for it in the resource-directories
 737               for (Resource resource : project.getResources())
 738               {
 739                 file = new File(resource.getDirectory() + File.separator + filename);
 740                 if (file.exists())
 741                   break;
 742               }
 743             }
 744             if (file != null && file.exists())
 745             {
 746               InputStream is = new FileInputStream(file);
 747               byte[] buffer = new byte[1024*4]; // copy data in 4MB-chunks
 748               int i;
 749               while((i = is.read(buffer)) > -1)
 750                 digest.update(buffer, 0, i);
 751               is.close();
 752               byte[] bytes = digest.digest();
 753               BigInteger bi = new BigInteger(1, bytes);
 754               String newMd5 = String.format("%0" + (bytes.length << 1) + "x", bi);
 755               String oldMd5 = !md5s.containsKey(filename) ? "" : md5s.get(filename);
 756               if (!newMd5.equals(oldMd5))
 757               {
 758                 getLog().debug("Found new or modified mapping-file: " + filename);
 759                 modified = true;
 760                 md5s.put(filename, newMd5);
 761               }
 762               else
 763               {
 764                 getLog().debug(oldMd5 + " -> mapping-file unchanged: " + filename);
 765               }
 766               getLog().debug("Adding mappings from XML-configurationfile: " + file);
 767               config.addFile(file);
 768             }
 769             else
 770               throw new MojoFailureException("File " + filename + " could not be found in any of the configured resource-directories!");
 771           }
 772         }
 773         catch (NoSuchAlgorithmException e)
 774         {
 775           throw new MojoFailureException("Cannot calculate MD5 sums!", e);
 776         }
 777         catch (FileNotFoundException e)
 778         {
 779           throw new MojoFailureException("Cannot calculate MD5 sums!", e);
 780         }
 781         catch (IOException e)
 782         {
 783           throw new MojoFailureException("Cannot calculate MD5 sums!", e);
 784         }
 785       }
 786
 787       Target target = null;
 788       try
 789       {
 790         target = Target.valueOf(this.target.toUpperCase());
 791       }
 792       catch (IllegalArgumentException e)
 793       {
 794         getLog().error("Invalid value for configuration-option \"target\": " + this.target);
 795         getLog().error("Valid values are: NONE, SCRIPT, EXPORT, BOTH");
 796         throw new MojoExecutionException("Invalid value for configuration-option \"target\"");
 797       }
 798       Type type = null;
 799       try
 800       {
 801         type = Type.valueOf(this.type.toUpperCase());
 802       }
 803       catch (IllegalArgumentException e)
 804       {
 805         getLog().error("Invalid value for configuration-option \"type\": " + this.type);
 806         getLog().error("Valid values are: NONE, CREATE, DROP, BOTH");
 807         throw new MojoExecutionException("Invalid value for configuration-option \"type\"");
 808       }
 809
 810       if (target.equals(Target.SCRIPT) || target.equals(Target.NONE))
 811       {
 812         project.getProperties().setProperty(EXPORT_SKIPPED_PROPERTY, "true");
 813       }
 814       if (
 815           !modified
 816           && !target.equals(Target.SCRIPT)
 817           && !target.equals(Target.NONE)
 818           && !force
 819         )
 820       {
 821         getLog().info("No modified annotated classes or mapping-files found and dialect unchanged.");
 822         getLog().info("Skipping schema generation!");
 823         project.getProperties().setProperty(EXPORT_SKIPPED_PROPERTY, "true");
 824         return;
 825       }
 826
 827       getLog().info("Gathered hibernate-configuration (turn on debugging for details):");
 828       for (Entry<Object,Object> entry : properties.entrySet())
 829         getLog().info("  " + entry.getKey() + " = " + entry.getValue());
 830
 831       try
 832       {
 833         /**
 834          * The connection must be established outside of hibernate, because
 835          * hibernate does not use the context-classloader of the current
 836          * thread and, hence, would not be able to resolve the driver-class!
 837          */
 838         getLog().debug("Target: " + target + ", Type: " + type);
 839         switch (target)
 840         {
 841           case EXPORT:
 842           case BOTH:
 843             switch (type)
 844             {
 845               case CREATE:
 846               case DROP:
 847               case BOTH:
 848                 Class driverClass = classLoader.loadClass(properties.getProperty(DRIVER_CLASS));
 849                 getLog().debug("Registering JDBC-driver " + driverClass.getName());
 850                 DriverManager.registerDriver(new DriverProxy((Driver)driverClass.newInstance()));
 851                 getLog().debug(
 852                     "Opening JDBC-connection to "
 853                     + properties.getProperty(URL)
 854                     + " as "
 855                     + properties.getProperty(USERNAME)
 856                     + " with password "
 857                     + properties.getProperty(PASSWORD)
 858                     );
 859                 connection = DriverManager.getConnection(
 860                     properties.getProperty(URL),
 861                     properties.getProperty(USERNAME),
 862                     properties.getProperty(PASSWORD)
 863                     );
 864             }
 865         }
 866       }
 867       catch (ClassNotFoundException e)
 868       {
 869         getLog().error("Dependency for driver-class " + properties.getProperty(DRIVER_CLASS) + " is missing!");
 870         throw new MojoExecutionException(e.getMessage());
 871       }
 872       catch (Exception e)
 873       {
 874         getLog().error("Cannot establish connection to database!");
 875         Enumeration<Driver> drivers = DriverManager.getDrivers();
 876         if (!drivers.hasMoreElements())
 877           getLog().error("No drivers registered!");
 878         while (drivers.hasMoreElements())
 879           getLog().debug("Driver: " + drivers.nextElement());
 880         throw new MojoExecutionException(e.getMessage());
 881       }
 882
 883       config.buildMappings();
 884
 885       if (envers)
 886       {
 887         getLog().info("Automatic auditing via hibernate-envers enabled!");
 888         AuditConfiguration.getFor(config);
 889       }
 890
 891       SchemaExport export = new SchemaExport(config, connection);
 892       export.setDelimiter(delimiter);
 893       export.setFormat(format);
 894
 895       File outF = new File(outputFile);
 896
 897       if (!outF.isAbsolute())
 898       {
 899         // Interpret relative file path relative to build directory
 900         outF = new File(buildDirectory, outputFile);
 901         getLog().info("Adjusted relative path, resulting path is " + outF.getPath());
 902       }
 903
 904       // Ensure that directory path for specified file exists
 905       File outFileParentDir = outF.getParentFile();
 906       if (null != outFileParentDir && !outFileParentDir.exists())
 907       {
 908         try
 909         {
 910           getLog().info("Creating directory path for output file:" + outFileParentDir.getPath());
 911           outFileParentDir.mkdirs();
 912         }
 913         catch (Exception e)
 914         {
 915           getLog().error("Error creating directory path for output file: " + e.getLocalizedMessage());
 916         }
 917       }
 918
 919       export.setOutputFile(outF.getPath());
 920       export.execute(target, type);
 921
 922       for (Object exception : export.getExceptions())
 923         getLog().debug(exception.toString());
 924     }
 925     finally
 926     {
 927       /** Stop Log-Capturing */
 928       MavenLogAppender.endPluginLog(this);
 929
 930       /** Restore the old class-loader (TODO: is this really necessary?) */
 931       Thread.currentThread().setContextClassLoader(contextClassLoader);
 932
 933       /** Close the connection */
 934       try
 935       {
 936         if (connection != null)
 937           connection.close();
 938       }
 939       catch (SQLException e)
 940       {
 941         getLog().error("Error while closing connection: " + e.getMessage());
 942       }
 943     }
 944
 945     /** Write md5-sums for annotated classes to file */
 946     try
 947     {
 948       FileOutputStream fos = new FileOutputStream(saved);
 949       ObjectOutputStream oos = new ObjectOutputStream(fos);
 950       oos.writeObject(md5s);
 951       oos.close();
 952       fos.close();
 953     }
 954     catch (Exception e)
 955     {
 956       getLog().error("Cannot write md5-sums to file: " + e);
 957     }
 958   }
 959
 960   /**
 961    * Needed, because DriverManager won't pick up drivers, that were not
 962    * loaded by the system-classloader!
 963    * See:
 964    * http://stackoverflow.com/questions/288828/how-to-use-a-jdbc-driver-fromodifiedm-an-arbitrary-location
 965    */
 966   static final class DriverProxy implements Driver
 967   {
 968     private final Driver target;
 969
 970     DriverProxy(Driver target)
 971     {
 972       if (target == null)
 973         throw new NullPointerException();
 974       this.target = target;
 975     }
 976
 977     public java.sql.Driver getTarget()
 978     {
 979       return target;
 980     }
 981
 982     @Override
 983     public boolean acceptsURL(String url) throws SQLException
 984     {
 985       return target.acceptsURL(url);
 986     }
 987
 988     @Override
 989     public java.sql.Connection connect(
 990         String url,
 991         java.util.Properties info
 992       )
 993       throws
 994         SQLException
 995     {
 996       return target.connect(url, info);
 997     }
 998
 999     @Override
1000     public int getMajorVersion()
1001     {
1002       return target.getMajorVersion();
1003     }
1004
1005     @Override
1006     public int getMinorVersion()
1007     {
1008       return target.getMinorVersion();
1009     }
1010
1011     @Override
1012     public DriverPropertyInfo[] getPropertyInfo(
1013         String url,
1014         Properties info
1015       )
1016       throws
1017         SQLException
1018     {
1019       return target.getPropertyInfo(url, info);
1020     }
1021
1022     @Override
1023     public boolean jdbcCompliant()
1024     {
1025       return target.jdbcCompliant();
1026     }
1027
1028     /**
1029      * This Method cannot be annotated with @Override, becaus the plugin
1030      * will not compile then under Java 1.6!
1031      */
1032     public Logger getParentLogger() throws SQLFeatureNotSupportedException
1033     {
1034       throw new SQLFeatureNotSupportedException("Not supported, for backward-compatibility with Java 1.6");
1035     }
1036
1037     @Override
1038     public String toString()
1039     {
1040       return "Proxy: " + target;
1041     }
1042
1043     @Override
1044     public int hashCode()
1045     {
1046       return target.hashCode();
1047     }
1048
1049     @Override
1050     public boolean equals(Object obj)
1051     {
1052       if (!(obj instanceof DriverProxy))
1053         return false;
1054       DriverProxy other = (DriverProxy) obj;
1055       return this.target.equals(other.target);
1056     }
1057   }
1058 }