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