Upgraded the versions of javax.el-api and wagon-ssh-external

[hibernate-maven-plugin] / src / main / java / de / juplo / plugins / hibernate / AbstractSchemaMojo.java

package de.juplo.plugins.hibernate;


import com.pyx4j.log4j.MavenLogAppender;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.NoSuchAlgorithmException;
import java.time.ZonedDateTime;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.persistence.Embeddable;
import javax.persistence.Entity;
import javax.persistence.MappedSuperclass;
import javax.persistence.spi.PersistenceUnitTransactionType;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.hibernate.boot.MetadataBuilder;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.cfgxml.internal.ConfigLoader;
import org.hibernate.boot.cfgxml.spi.LoadedConfig;
import org.hibernate.boot.cfgxml.spi.MappingReference;
import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
import org.hibernate.boot.registry.BootstrapServiceRegistry;
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
import org.hibernate.boot.registry.selector.spi.StrategySelector;
import org.hibernate.boot.spi.MetadataImplementor;
import org.hibernate.cfg.AvailableSettings;
import static org.hibernate.cfg.AvailableSettings.DIALECT;
import static org.hibernate.cfg.AvailableSettings.DRIVER;
import static org.hibernate.cfg.AvailableSettings.FORMAT_SQL;
import static org.hibernate.cfg.AvailableSettings.HBM2DDL_DELIMITER;
import static org.hibernate.cfg.AvailableSettings.HBM2DLL_CREATE_NAMESPACES;
import static org.hibernate.cfg.AvailableSettings.IMPLICIT_NAMING_STRATEGY;
import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_DRIVER;
import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_PASSWORD;
import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_URL;
import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_USER;
import static org.hibernate.cfg.AvailableSettings.PASS;
import static org.hibernate.cfg.AvailableSettings.PHYSICAL_NAMING_STRATEGY;
import static org.hibernate.cfg.AvailableSettings.SHOW_SQL;
import static org.hibernate.cfg.AvailableSettings.USER;
import static org.hibernate.cfg.AvailableSettings.URL;
import org.hibernate.engine.config.spi.ConfigurationService;
import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
import org.hibernate.internal.util.config.ConfigurationException;
import org.hibernate.jpa.boot.internal.ParsedPersistenceXmlDescriptor;
import org.hibernate.jpa.boot.internal.PersistenceXmlParser;
import org.hibernate.tool.schema.TargetType;
import org.hibernate.tool.schema.internal.ExceptionHandlerCollectingImpl;
import org.hibernate.tool.schema.internal.exec.ScriptTargetOutputToFile;
import org.hibernate.tool.schema.spi.ExecutionOptions;
import org.hibernate.tool.schema.spi.SchemaManagementToolCoordinator;
import org.hibernate.tool.schema.spi.ScriptTargetOutput;
import org.hibernate.tool.schema.spi.TargetDescriptor;
import org.scannotation.AnnotationDB;


/**
 * Baseclass with common attributes and methods.
 *
 * @phase process-classes
 * @threadSafe
 * @requiresDependencyResolution runtime
 */
public abstract class AbstractSchemaMojo extends AbstractMojo
{
  public final static String EXECUTE = "hibernate.schema.execute";
  public final static String OUTPUTDIRECTORY = "project.build.outputDirectory";
  public final static String SCAN_CLASSES = "hibernate.schema.scan.classes";
  public final static String SCAN_DEPENDENCIES = "hibernate.schema.scan.dependencies";
  public final static String SCAN_TESTCLASSES = "hibernate.schema.scan.test_classes";
  public final static String TEST_OUTPUTDIRECTORY = "project.build.testOutputDirectory";
  public final static String SKIPPED = "hibernate.schema.skipped";
  public final static String SCRIPT = "hibernate.schema.script";

  private final static Pattern SPLIT = Pattern.compile("[^,\\s]+");

  private final Set<String> packages = new HashSet<String>();


  /**
   * The maven project.
   * <p>
   * Only needed internally.
   *
   * @parameter property="project"
   * @required
   * @readonly
   */
  private MavenProject project;

  /**
   * Build-directory.
   * <p>
   * Only needed internally.
   *
   * @parameter property="project.build.directory"
   * @required
   * @readonly
   */
  private String buildDirectory;


  /** Parameters to configure the genaration of the SQL *********************/

  /**
   * Excecute the generated SQL.
   * If set to <code>false</code>, only the SQL-script is created and the
   * database is not touched.
   * <p>
   * <strong>Important:</strong>
   * This configuration value can only be configured through the
   * <code>pom.xml</code>, or by the definition of a system-property, because
   * it is not known by Hibernate nor JPA and, hence, not picked up from
   * their configuration!
   *
   * @parameter property="hibernate.schema.execute" default-value="true"
   * @since 2.0
   */
  private Boolean execute;

  /**
   * Skip execution
   * <p>
   * If set to <code>true</code>, the execution is skipped.
   * <p>
   * A skipped execution is signaled via the maven-property
   * <code>${hibernate.schema.skipped}</code>.
   * <p>
   * The execution is skipped automatically, if no modified or newly added
   * annotated classes are found and the dialect was not changed.
   * <p>
   * <strong>Important:</strong>
   * This configuration value can only be configured through the
   * <code>pom.xml</code>, or by the definition of a system-property, because
   * it is not known by Hibernate nor JPA and, hence, not picked up from
   * their configuration!
   *
   * @parameter property="hibernate.schema.skip" default-value="${maven.test.skip}"
   * @since 1.0
   */
  private boolean skip;

  /**
   * Force generation/execution
   * <p>
   * Force the generation and (if configured) the execution of the SQL, even if
   * no modified or newly added annotated classes where found and the
   * configuration was not changed.
   * <p>
   * <code>skip</code> takes precedence over <code>force</code>.
   * <p>
   * <strong>Important:</strong>
   * This configuration value can only be configured through the
   * <code>pom.xml</code>, or by the definition of a system-property, because
   * it is not known by Hibernate nor JPA and, hence, not picked up from
   * their configuration!
   *
   * @parameter property="hibernate.schema.force" default-value="false"
   * @since 1.0
   */
  private boolean force;

  /**
   * Hibernate dialect.
   *
   * @parameter property="hibernate.dialect"
   * @since 1.0
   */
  private String dialect;

  /**
   * Delimiter in output-file.
   * <p>
   * <strong>Important:</strong>
   * This configuration value can only be configured through the
   * <code>pom.xml</code>, or by the definition of a system-property, because
   * it is not known by Hibernate nor JPA and, hence, not picked up from
   * their configuration!
   *
   * @parameter property="hibernate.hbm2ddl.delimiter" default-value=";"
   * @since 1.0
   */
  private String delimiter;

  /**
   * Show the generated SQL in the command-line output.
   *
   * @parameter property="hibernate.show_sql"
   * @since 1.0
   */
  private Boolean show;

  /**
   * Format output-file.
   *
   * @parameter property="hibernate.format_sql"
   * @since 1.0
   */
  private Boolean format;

  /**
   * Specifies whether to automatically create also the database schema/catalog.
   *
   * @parameter property="hibernate.hbm2dll.create_namespaces" default-value="false"
   * @since 2.0
   */
  private Boolean createNamespaces;

  /**
   * Implicit naming strategy
   *
   * @parameter property="hibernate.implicit_naming_strategy"
   * @since 2.0
   */
  private String implicitNamingStrategy;

  /**
   * Physical naming strategy
   *
   * @parameter property="hibernate.physical_naming_strategy"
   * @since 2.0
   */
  private String physicalNamingStrategy;

  /**
   * Wether the project should be scanned for annotated-classes, or not
   * <p>
   * This parameter is intended to allow overwriting of the parameter
   * <code>exclude-unlisted-classes</code> of a <code>persistence-unit</code>.
   * If not specified, it defaults to <code>true</code>
   *
   * @parameter property="hibernate.schema.scan.classes"
   * @since 2.0
   */
  private Boolean scanClasses;

  /**
   * Classes-Directory to scan.
   * <p>
   * This parameter defaults to the maven build-output-directory for classes.
   * Additionally, all dependencies are scanned for annotated classes.
   * <p>
   * <strong>Important:</strong>
   * This configuration value can only be configured through the
   * <code>pom.xml</code>, or by the definition of a system-property, because
   * it is not known by Hibernate nor JPA and, hence, not picked up from
   * their configuration!
   *
   * @parameter property="project.build.outputDirectory"
   * @since 1.0
   */
  private String outputDirectory;

  /**
   * Dependency-Scopes, that should be scanned for annotated classes.
   * <p>
   * By default, only dependencies in the scope <code>compile</code> are
   * scanned for annotated classes. Multiple scopes can be seperated by
   * white space or commas.
   * <p>
   * If you do not want any dependencies to be scanned for annotated
   * classes, set this parameter to <code>none</code>.
   * <p>
   * The plugin does not scan for annotated classes in transitive
   * dependencies. If some of your annotated classes are hidden in a
   * transitive dependency, you can simply add that dependency explicitly.
   *
   * @parameter property="hibernate.schema.scan.dependencies" default-value="compile"
   * @since 1.0.3
   */
  private String scanDependencies;

  /**
   * Whether to scan the test-branch of the project for annotated classes, or
   * not.
   * <p>
   * If this parameter is set to <code>true</code> the test-classes of the
   * artifact will be scanned for hibernate-annotated classes additionally.
   * <p>
   * <strong>Important:</strong>
   * This configuration value can only be configured through the
   * <code>pom.xml</code>, or by the definition of a system-property, because
   * it is not known by Hibernate nor JPA and, hence, not picked up from
   * their configuration!
   *
   * @parameter property="hibernate.schema.scan.test_classes" default-value="false"
   * @since 1.0.1
   */
  private Boolean scanTestClasses;

  /**
   * Test-Classes-Directory to scan.
   * <p>
   * This parameter defaults to the maven build-output-directory for
   * test-classes.
   * <p>
   * This parameter is only used, when <code>scanTestClasses</code> is set
   * to <code>true</code>!
   * <p>
   * <strong>Important:</strong>
   * This configuration value can only be configured through the
   * <code>pom.xml</code>, or by the definition of a system-property, because
   * it is not known by Hibernate nor JPA and, hence, not picked up from
   * their configuration!
   *
   * @parameter property="project.build.testOutputDirectory"
   * @since 1.0.2
   */
  private String testOutputDirectory;


  /** Conection parameters *************************************************/

  /**
   * SQL-Driver name.
   *
   * @parameter property="hibernate.connection.driver_class"
   * @since 1.0
   */
  private String driver;

  /**
   * Database URL.
   *
   * @parameter property="hibernate.connection.url"
   * @since 1.0
   */
  private String url;

  /**
   * Database username
   *
   * @parameter property="hibernate.connection.username"
   * @since 1.0
   */
  private String username;

  /**
   * Database password
   *
   * @parameter property="hibernate.connection.password"
   * @since 1.0
   */
  private String password;


  /** Parameters to locate configuration sources ****************************/

  /**
   * Path to a file or name of a ressource with hibernate properties.
   * If this parameter is specified, the plugin will try to load configuration
   * values from a file with the given path or a ressource on the classpath with
   * the given name. If both fails, the execution of the plugin will fail.
   * <p>
   * If this parameter is not set the plugin will load configuration values
   * from a ressource named <code>hibernate.properties</code> on the classpath,
   * if it is present, but will not fail if there is no such ressource.
   * <p>
   * During ressource-lookup, the test-classpath takes precedence.
   *
   * @parameter
   * @since 1.0
   */
  private String hibernateProperties;

  /**
   * Path to Hibernate configuration file (.cfg.xml).
   * If this parameter is specified, the plugin will try to load configuration
   * values from a file with the given path or a ressource on the classpath with
   * the given name. If both fails, the execution of the plugin will fail.
   * <p>
   * If this parameter is not set the plugin will load configuration values
   * from a ressource named <code>hibernate.cfg.xml</code> on the classpath,
   * if it is present, but will not fail if there is no such ressource.
   * <p>
   * During ressource-lookup, the test-classpath takes precedence.
   * <p>
   * Settings in this file will overwrite settings in the properties file.
   *
   * @parameter
   * @since 1.1.0
   */
  private String hibernateConfig;

  /**
   * Name of the persistence-unit.
   * If this parameter is specified, the plugin will try to load configuration
   * values from a persistence-unit with the specified name. If no such
   * persistence-unit can be found, the plugin will throw an exception.
   * <p>
   * If this parameter is not set and there is only one persistence-unit
   * available, that unit will be used automatically. But if this parameter is
   * not set and there are multiple persistence-units available on,
   * the class-path, the execution of the plugin will fail.
   * <p>
   * Settings in this file will overwrite settings in the properties or the
   * configuration file.
   *
   * @parameter
   * @since 1.1.0
   */
  private String persistenceUnit;

  /**
   * List of Hibernate-Mapping-Files (XML).
   * Multiple files can be separated with white-spaces and/or commas.
   *
   * @parameter property="hibernate.mapping"
   * @since 1.0.2
   */
  private String mappings;



  public final void execute(String filename)
    throws
      MojoFailureException,
      MojoExecutionException
  {
    if (skip)
    {
      getLog().info("Execution of hibernate-maven-plugin was skipped!");
      project.getProperties().setProperty(SKIPPED, "true");
      return;
    }

    ModificationTracker tracker;
    try
    {
      tracker = new ModificationTracker(buildDirectory, filename, getLog());
    }
    catch (NoSuchAlgorithmException e)
    {
      throw new MojoFailureException("Digest-Algorithm MD5 is missing!", e);
    }

    final SimpleConnectionProvider connectionProvider =
        new SimpleConnectionProvider(getLog());

    try
    {
      /** Start extended logging */
      MavenLogAppender.startPluginLog(this);

      /** Load checksums for old mapping and configuration */
      tracker.load();

      /** Create the ClassLoader */
      MutableClassLoader classLoader = createClassLoader();

      /** Create a BootstrapServiceRegistry with the created ClassLoader */
      BootstrapServiceRegistry bootstrapServiceRegitry =
          new BootstrapServiceRegistryBuilder()
              .applyClassLoader(classLoader)
              .build();
      ClassLoaderService classLoaderService =
          bootstrapServiceRegitry.getService(ClassLoaderService.class);

      Properties properties = new Properties();
      ConfigLoader configLoader = new ConfigLoader(bootstrapServiceRegitry);

      /** Loading configuration */
      properties.putAll(loadProperties(configLoader));
      LoadedConfig config = loadConfig(configLoader);
      if (config != null)
        properties.putAll(config.getConfigurationValues());

      /** Add the remaining class-path-elements */
      addDirectDependenciesClassPath(classLoader);

      /** Loading and merging configuration from persistence-unit(s) */
      ParsedPersistenceXmlDescriptor unit =
          loadPersistenceUnit(classLoaderService, properties);
      if (unit != null)
        properties.putAll(unit.getProperties());

      /** Overwriting/Completing configuration */
      configure(properties, tracker);

      /** Check configuration for modifications */
      if(tracker.track(properties))
        getLog().debug("Configuration has changed.");
      else
        getLog().debug("Configuration unchanged.");

      /** Check, that the outputfile is writable */
      final File output = getOutputFile(filename);
      /** Check, if the outputfile is missing or was changed */
      checkOutputFile(output, tracker);

      /** Configure Hibernate */
      final StandardServiceRegistry serviceRegistry =
          new StandardServiceRegistryBuilder(bootstrapServiceRegitry)
              .applySettings(properties)
              .addService(ConnectionProvider.class, connectionProvider)
              .build();
      final MetadataSources sources = new MetadataSources(serviceRegistry);

      /** Add the remaining class-path-elements */
      addAllDependenciesToClassPath(classLoader);

      /** Apply mappings from hibernate-configuration, if present */
      if (config != null)
      {
        for (MappingReference mapping : config.getMappingReferences())
          mapping.apply(sources);
      }

      Set<String> classes;
      if (unit == null)
      {
        /** No persistent unit: default behaviour */
        if (scanClasses == null)
          scanClasses = true;
        Set<URL> urls = new HashSet<URL>();
        getLog().debug("Compiling the dependencies, that are scanned for annotated classes");
        if (scanClasses)
          addRoot(urls, outputDirectory);
        if (scanTestClasses)
          addRoot(urls, testOutputDirectory);
        addDependencies(urls);
        classes = scanUrls(urls);
      }
      else
      {
        /** Follow configuration in persisten unit */
        if (scanClasses == null)
          scanClasses = !unit.isExcludeUnlistedClasses();
        getLog().debug("Compiling the dependencies, that are scanned for annotated classes");

        Set<URL> urls = new HashSet<URL>();
        if (scanClasses)
        {
          getLog().debug("Only dependencies relative to persistent-unit " + unit.getName() + " are scanned!");
          /**
           * Scan the root of the persiten unit and configured jars for
           * annotated classes
           */
          getLog().debug(" - adding " + unit.getPersistenceUnitRootUrl());
          urls.add(unit.getPersistenceUnitRootUrl());
          for (URL url : unit.getJarFileUrls())
          {
            getLog().debug(" - adding " + url);
            urls.add(url);
          }
          if (scanTestClasses)
            addRoot(urls, testOutputDirectory);
        }
        else
          getLog().debug("Scanning of unlisted classes is prohibited in persistent-unit " + unit.getName());
        classes = scanUrls(urls);
        for (String className : unit.getManagedClassNames())
          classes.add(className);
        /**
         * Add mappings from the default mapping-file
         * <code>META-INF/orm.xml</code>, if present
         */
        boolean error = false;
        InputStream is;
        is = classLoader.getResourceAsStream("META-INF/orm.xml");
        if (is != null)
        {
          getLog().info("Adding default JPA-XML-mapping from META-INF/orm.xml");
          try
          {
            tracker.track("META-INF/orm.xml", is);
            sources.addResource("META-INF/orm.xml");
          }
          catch (IOException e)
          {
            getLog().error("cannot read META-INF/orm.xml: " + e);
            error = true;
          }
        }
        else
        {
          getLog().debug("no META-INF/orm.xml found");
        }
        /**
         * Add mappings from files, that are explicitly configured in the
         * persistence unit
         */
        getLog().info("Adding mappings from persistence-unit " + unit.getName());
        for (String mapping : unit.getMappingFileNames())
        {
          getLog().info(" - adding " + mapping);
          is = classLoader.getResourceAsStream(mapping);
          if (is != null)
          {
            try
            {
              tracker.track(mapping, is);
              sources.addResource(mapping);
            }
            catch (IOException e)
            {
              getLog().info("cannot read mapping-file " + mapping + ": " + e);
              error = true;
            }
          }
          else
          {
            getLog().error("cannot find mapping-file " + mapping);
            error = true;
          }
        }
        if (error)
          throw new MojoFailureException(
              "error, while reading mappings configured in persistence-unit \"" +
              unit.getName() +
              "\""
              );
      }

      /** Add the configured/collected annotated classes */
      for (String className : classes)
        addAnnotated(className, sources, classLoaderService, tracker);

      /** Add explicitly configured classes */
      addMappings(sources, tracker);

      /** Skip execution, if mapping and configuration is unchanged */
      if (!tracker.modified())
      {
        getLog().info("Mapping and configuration unchanged.");
        if (force)
          getLog().info("Generation/execution is forced!");
        else
        {
          getLog().info("Skipping schema generation!");
          project.getProperties().setProperty(SKIPPED, "true");
          return;
        }
      }


      /** Truncate output file */
      try
      {
        new FileOutputStream(output).getChannel().truncate(0).close();
      }
      catch (IOException e)
      {
        String error =
            "Error while truncating " + output.getAbsolutePath() + ": "
            + e.getMessage();
        getLog().warn(error);
        throw new MojoExecutionException(error);
      }

      /** Create a connection, if sufficient configuration infromation is available */
      connectionProvider.open(classLoaderService, properties);

      MetadataBuilder metadataBuilder = sources.getMetadataBuilder();

      StrategySelector strategySelector =
          serviceRegistry.getService(StrategySelector.class);

      if (properties.containsKey(IMPLICIT_NAMING_STRATEGY))
      {
        metadataBuilder.applyImplicitNamingStrategy(
            strategySelector.resolveStrategy(
                ImplicitNamingStrategy.class,
                properties.getProperty(IMPLICIT_NAMING_STRATEGY)
                )
            );
      }

      if (properties.containsKey(PHYSICAL_NAMING_STRATEGY))
      {
        metadataBuilder.applyPhysicalNamingStrategy(
            strategySelector.resolveStrategy(
                PhysicalNamingStrategy.class,
                properties.getProperty(PHYSICAL_NAMING_STRATEGY)
                )
            );
      }

      /** Prepare the generation of the SQL */
      Map settings = new HashMap();
      settings.putAll(
          serviceRegistry
              .getService(ConfigurationService.class)
              .getSettings()
              );
      ExceptionHandlerCollectingImpl handler =
          new ExceptionHandlerCollectingImpl();
      ExecutionOptions options =
          SchemaManagementToolCoordinator
              .buildExecutionOptions(settings, handler);
      final EnumSet<TargetType> targetTypes = EnumSet.of(TargetType.SCRIPT);
      if (execute)
        targetTypes.add(TargetType.DATABASE);
      TargetDescriptor target = new TargetDescriptor()
      {
        @Override
        public EnumSet<TargetType> getTargetTypes()
        {
          return targetTypes;
        }

        @Override
        public ScriptTargetOutput getScriptTargetOutput()
        {
          String charset =
              (String)
              serviceRegistry
                  .getService(ConfigurationService.class)
                  .getSettings()
                  .get(AvailableSettings.HBM2DDL_CHARSET_NAME);
          return new ScriptTargetOutputToFile(output, charset);
        }
      };

      /**
       * Change class-loader of current thread.
       * This is necessary, because still not all parts of Hibernate 5 use
       * the newly introduced ClassLoaderService and will fail otherwise!
       */
      Thread thread = Thread.currentThread();
      ClassLoader contextClassLoader = thread.getContextClassLoader();
      try
      {
        thread.setContextClassLoader(classLoader);
        build((MetadataImplementor)metadataBuilder.build(), options, target);
        if (handler.getExceptions().size() > 0)
        {
          StringBuilder builder = new StringBuilder();
          builder.append("Hibernate failed:");
          for (Exception e : handler.getExceptions())
          {
            builder.append("\n * ");
            builder.append(e.getMessage());
            AbstractSchemaMojo.printStrackTrace(builder, e);
            builder.append("\n");
          }
          String error = builder.toString();
          getLog().error(error);
          throw new MojoFailureException(error);
        }
      }
      finally
      {
        thread.setContextClassLoader(contextClassLoader);
        /** Track, the content of the generated script */
        checkOutputFile(output, tracker);
      }
    }
    catch (MojoExecutionException e)
    {
      tracker.failed();
      throw e;
    }
    catch (MojoFailureException e)
    {
      tracker.failed();
      throw e;
    }
    catch (RuntimeException e)
    {
      tracker.failed();
      throw e;
    }
    finally
    {
      /** Remember mappings and configuration */
      tracker.save();

      /** Close the connection - if one was opened */
      connectionProvider.close();

      /** Stop Log-Capturing */
      MavenLogAppender.endPluginLog(this);
    }
  }


  abstract void build(
      MetadataImplementor metadata,
      ExecutionOptions options,
      TargetDescriptor target
      )
    throws
      MojoFailureException,
      MojoExecutionException;


  private MutableClassLoader createClassLoader() throws MojoExecutionException
  {
    try
    {
      getLog().debug("Creating ClassLoader for project-dependencies...");
      LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
      File file;

      file = new File(testOutputDirectory);
      if (!file.exists())
      {
        getLog().info("Creating test-output-directory: " + testOutputDirectory);
        file.mkdirs();
      }
      urls.add(file.toURI().toURL());

      file = new File(outputDirectory);
      if (!file.exists())
      {
        getLog().info("Creating output-directory: " + outputDirectory);
        file.mkdirs();
      }
      urls.add(file.toURI().toURL());

      return new MutableClassLoader(urls, getLog());
    }
    catch (Exception e)
    {
      getLog().error("Error while creating ClassLoader!", e);
      throw new MojoExecutionException(e.getMessage());
    }
  }

  private void addDirectDependenciesClassPath(MutableClassLoader classLoader)
      throws
        MojoExecutionException
  {
    try
    {
      getLog().debug("Adding all direct project-dependencies to the ClassLoader...");
      LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
      addDependencies(urls);
      if (scanTestClasses)
        addRoot(urls, testOutputDirectory);
      classLoader.add(urls);
    }
    catch (Exception e)
    {
      getLog().error("Error while creating ClassLoader!", e);
      throw new MojoExecutionException(e.getMessage());
    }
  }

  private void addAllDependenciesToClassPath(MutableClassLoader classLoader)
      throws
        MojoExecutionException
  {
    try
    {
      getLog().debug("Adding all project-dependencies to the ClassLoader...");
      List<String> classpathFiles = project.getCompileClasspathElements();
      classpathFiles.addAll(project.getTestClasspathElements());
      LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
      for (String pathElement : classpathFiles)
      {
        getLog().debug(" - adding " + pathElement);
        urls.add(new File(pathElement).toURI().toURL());
      }
      classLoader.add(urls);
    }
    catch (Exception e)
    {
      getLog().error("Error while creating ClassLoader!", e);
      throw new MojoExecutionException(e.getMessage());
    }
  }

  private Map loadProperties(ConfigLoader configLoader)
      throws
        MojoExecutionException
  {
    /** Try to read configuration from properties-file */
    if (hibernateProperties == null)
    {
      try
      {
        return configLoader.loadProperties("hibernate.properties");
      }
      catch (ConfigurationException e)
      {
        getLog().debug(e.getMessage());
        return Collections.EMPTY_MAP;
      }
    }
    else
    {
      try
      {
        File file = new File(hibernateProperties);
        if (file.exists())
        {
          getLog().info("Reading settings from file " + hibernateProperties + "...");
          return configLoader.loadProperties(file);
        }
        else
          return configLoader.loadProperties(hibernateProperties);
      }
      catch (ConfigurationException e)
      {
        getLog().error("Error while reading properties!", e);
        throw new MojoExecutionException(e.getMessage());
      }
    }
  }

  private LoadedConfig loadConfig(ConfigLoader configLoader)
      throws MojoExecutionException
  {
    /** Try to read configuration from configuration-file */
    if (hibernateConfig == null)
    {
      try
      {
        return configLoader.loadConfigXmlResource("hibernate.cfg.xml");
      }
      catch (ConfigurationException e)
      {
        getLog().debug(e.getMessage());
        return null;
      }
    }
    else
    {
      try
      {
        File file = new File(hibernateConfig);
        if (file.exists())
        {
          getLog().info("Reading configuration from file " + hibernateConfig + "...");
          return configLoader.loadConfigXmlFile(file);
        }
        else
        {
          return configLoader.loadConfigXmlResource(hibernateConfig);
        }
      }
      catch (ConfigurationException e)
      {
        getLog().error("Error while reading configuration!", e);
        throw new MojoExecutionException(e.getMessage());
      }
    }
  }

  private void configure(Properties properties, ModificationTracker tracker)
      throws MojoFailureException
  {
    /**
     * Special treatment for the configuration-value "execute": if it is
     * switched to "true", the genearation fo the schema should be forced!
     */
    if (tracker.check(EXECUTE, execute.toString()) && execute)
    {
      getLog().info(
          "hibernate.schema.execute was switched on: " +
          "forcing generation/execution of SQL"
          );
      tracker.touch();
    }
    configure(properties, execute, EXECUTE);

    /**
     * Configure the generation of the SQL.
     * Overwrite values from properties-file if the configuration parameter is
     * known to Hibernate.
     */
    configure(properties, dialect, DIALECT);
    configure(properties, delimiter, HBM2DDL_DELIMITER);
    configure(properties, format, FORMAT_SQL);
    configure(properties, createNamespaces, HBM2DLL_CREATE_NAMESPACES);
    configure(properties, implicitNamingStrategy, IMPLICIT_NAMING_STRATEGY);
    configure(properties, physicalNamingStrategy, PHYSICAL_NAMING_STRATEGY);
    configure(properties, outputDirectory, OUTPUTDIRECTORY);
    configure(properties, scanDependencies, SCAN_DEPENDENCIES);
    configure(properties, scanTestClasses, SCAN_TESTCLASSES);
    configure(properties, testOutputDirectory, TEST_OUTPUTDIRECTORY);

    /**
     * Special treatment for the configuration-value "show": a change of its
     * configured value should not lead to a regeneration of the database
     * schama!
     */
    if (show == null)
      show = Boolean.valueOf(properties.getProperty(SHOW_SQL));
    else
      properties.setProperty(SHOW_SQL, show.toString());

    /**
     * Configure the connection parameters.
     * Overwrite values from properties-file.
     */
    configure(properties, driver, DRIVER, JPA_JDBC_DRIVER);
    configure(properties, url, URL, JPA_JDBC_URL);
    configure(properties, username, USER, JPA_JDBC_USER);
    configure(properties, password, PASS, JPA_JDBC_PASSWORD);

    if (properties.isEmpty())
    {
      getLog().error("No properties set!");
      throw new MojoFailureException("Hibernate configuration is missing!");
    }

    getLog().info("Gathered configuration:");
    for (Entry<Object,Object> entry : properties.entrySet())
      getLog().info("  " + entry.getKey() + " = " + entry.getValue());
  }

  private void configure(
      Properties properties,
      String value,
      String key,
      String alternativeKey
      )
  {
    configure(properties, value, key);

    if (properties.containsKey(alternativeKey))
    {
      if (properties.containsKey(key))
      {
        getLog().warn(
            "Ignoring property " + alternativeKey + "=\"" +
            properties.getProperty(alternativeKey) +
            "\" in favour for property " + key + "=\"" +
            properties.getProperty(key) + "\""
            );
        properties.remove(alternativeKey);
      }
      else
      {
        value = properties.getProperty(alternativeKey);
        properties.remove(alternativeKey);
        getLog().info(
            "Using value \"" + value + "\" from property " + alternativeKey +
            " for property " + key
            );
        properties.setProperty(key, value);
      }
    }
  }

  private void configure(Properties properties, String value, String key)
  {
    if (value != null)
    {
      if (properties.containsKey(key))
      {
        if (!properties.getProperty(key).equals(value))
        {
          getLog().info(
              "Overwriting property " + key + "=\"" +
              properties.getProperty(key) +
              "\" with value \"" + value + "\""
              );
          properties.setProperty(key, value);
        }
      }
      else
      {
        getLog().debug("Using value \"" + value + "\" for property " + key);
        properties.setProperty(key, value);
      }
    }
  }

  private void configure(Properties properties, Boolean value, String key)
  {
    configure(properties, value == null ? null : value.toString(), key);
  }

  private File getOutputFile(String filename)
      throws
        MojoExecutionException
  {
    File output = new File(filename);

    if (!output.isAbsolute())
    {
      // Interpret relative file path relative to build directory
      output = new File(buildDirectory, filename);
    }
    getLog().debug("Output file: " + output.getPath());

    // Ensure that directory path for specified file exists
    File outFileParentDir = output.getParentFile();
    if (null != outFileParentDir && !outFileParentDir.exists())
    {
      try
      {
        getLog().info(
            "Creating directory path for output file:" +
            outFileParentDir.getPath()
            );
        outFileParentDir.mkdirs();
      }
      catch (Exception e)
      {
        String error =
            "Error creating directory path for output file: " + e.getMessage();
        getLog().error(error);
        throw new MojoExecutionException(error);
      }
    }

    try
    {
      output.createNewFile();
    }
    catch (IOException e)
    {
      String error = "Error creating output file: " + e.getMessage();
      getLog().error(error);
      throw new MojoExecutionException(error);
    }

    if (!output.canWrite())
    {
      String error =
          "Output file " + output.getAbsolutePath() + " is not writable!";
      getLog().error(error);
      throw new MojoExecutionException(error);
    }

    return output;
  }

  private void checkOutputFile(File output, ModificationTracker tracker)
      throws
        MojoExecutionException
  {
    try
    {
      if (output.exists())
        tracker.track(SCRIPT, new FileInputStream(output));
      else
        tracker.track(SCRIPT, ZonedDateTime.now().toString());
    }
    catch (IOException e)
    {
      String error =
          "Error while checking the generated script: " + e.getMessage();
      getLog().error(error);
      throw new MojoExecutionException(error);
    }
  }

  private void addMappings(MetadataSources sources, ModificationTracker tracker)
      throws MojoFailureException
  {
    getLog().debug("Adding explicitly configured mappings...");
    if (mappings != null)
    {
      try
      {
        for (String filename : mappings.split("[\\s,]+"))
        {
          // First try the filename as absolute/relative path
          File file = new File(filename);
          if (!file.exists())
          {
            // If the file was not found, search for it in the resource-directories
            for (Resource resource : project.getResources())
            {
              file = new File(resource.getDirectory() + File.separator + filename);
              if (file.exists())
                break;
            }
          }
          if (file.exists())
          {
            if (file.isDirectory())
              // TODO: add support to read all mappings under a directory
              throw new MojoFailureException(file.getAbsolutePath() + " is a directory");
            if (tracker.track(filename, new FileInputStream(file)))
              getLog().debug(" - found new or modified mapping-file: " + filename);
            else
              getLog().debug(" - mapping-file unchanged: " + filename);

            sources.addFile(file);
          }
          else
            throw new MojoFailureException("File " + filename + " could not be found in any of the configured resource-directories!");
        }
      }
      catch (IOException e)
      {
        throw new MojoFailureException("Cannot calculate MD5 sums!", e);
      }
    }
  }

  private void addRoot(Set<URL> urls, String path) throws MojoFailureException
  {
    try
    {
      File dir = new File(path);
      if (dir.exists())
      {
        getLog().info(" - adding " + dir.getAbsolutePath());
        urls.add(dir.toURI().toURL());
      }
      else
        getLog().warn(
            "The directory cannot be scanned for annotated classes, " +
            "because it does not exist: " +
            dir.getAbsolutePath()
            );
    }
    catch (MalformedURLException e)
    {
      getLog().error("error while adding the project-root to the list of roots to scan!", e);
      throw new MojoFailureException(e.getMessage());
    }
  }

  private void addDependencies(Set<URL> urls) throws MojoFailureException
  {
    try
    {
      if (scanDependencies != null)
      {
        Matcher matcher = SPLIT.matcher(scanDependencies);
        while (matcher.find())
        {
          getLog().debug("Adding dependencies from scope " + matcher.group() + " to the list of roots to scan");
          for (Artifact artifact : project.getDependencyArtifacts())
          {
            if (!artifact.getScope().equalsIgnoreCase(matcher.group()))
              continue;
            if (artifact.getFile() == null)
            {
              getLog().warn("Cannot add dependency " + artifact.getId() + ": no JAR-file available!");
              continue;
            }
            getLog().debug(" - adding " + artifact.getId());
            urls.add(artifact.getFile().toURI().toURL());
          }
        }
      }
    }
    catch (MalformedURLException e)
    {
      getLog().error("Error while adding dependencies to the list of roots to scan!", e);
      throw new MojoFailureException(e.getMessage());
    }
  }

  private Set<String> scanUrls(Set<URL> scanRoots)
      throws
        MojoFailureException
  {
    try
    {
      AnnotationDB db = new AnnotationDB();
      for (URL root : scanRoots)
        db.scanArchives(root);

      Set<String> classes = new HashSet<String>();
      if (db.getAnnotationIndex().containsKey(Entity.class.getName()))
        classes.addAll(db.getAnnotationIndex().get(Entity.class.getName()));
      if (db.getAnnotationIndex().containsKey(MappedSuperclass.class.getName()))
        classes.addAll(db.getAnnotationIndex().get(MappedSuperclass.class.getName()));
      if (db.getAnnotationIndex().containsKey(Embeddable.class.getName()))
        classes.addAll(db.getAnnotationIndex().get(Embeddable.class.getName()));

      return classes;
    }
    catch (Exception e)
    {
      getLog().error("Error while scanning!", e);
      throw new MojoFailureException(e.getMessage());
    }
  }

  private void addAnnotated(
      String name,
      MetadataSources sources,
      ClassLoaderService classLoaderService,
      ModificationTracker tracker
      )
      throws
        MojoFailureException,
        MojoExecutionException
  {
    try
    {
      getLog().info("Adding annotated resource: " + name);
      String packageName = null;

      boolean error = false;
      try
      {
        Class<?> annotatedClass = classLoaderService.classForName(name);
        String resourceName = annotatedClass.getName();
        resourceName =
            resourceName.substring(
                resourceName.lastIndexOf(".") + 1,
                resourceName.length()
                ) + ".class";
        InputStream is = annotatedClass.getResourceAsStream(resourceName);
        if (is != null)
        {
          if (tracker.track(name, is))
            getLog().debug("New or modified class: " + name);
          else
            getLog().debug("Unchanged class: " + name);
          sources.addAnnotatedClass(annotatedClass);
          packageName = annotatedClass.getPackage().getName();
        }
        else
        {
          getLog().error("cannot find ressource " + resourceName + " for class " + name);
          error = true;
        }
      }
      catch(ClassLoadingException e)
      {
        packageName = name;
      }
      if (error)
      {
        throw new MojoExecutionException("error while inspecting annotated class " + name);
      }

      while (packageName != null)
      {
        if (packages.contains(packageName))
          return;
        String resource = packageName.replace('.', '/') + "/package-info.class";
        InputStream is = classLoaderService.locateResourceStream(resource);
        if (is == null)
        {
          // No compiled package-info available: no package-level annotations!
          getLog().debug("Package " + packageName + " is not annotated.");
        }
        else
        {
          if (tracker.track(packageName, is))
            getLog().debug("New or modified package: " + packageName);
          else
           getLog().debug("Unchanged package: " + packageName);
          getLog().info("Adding annotations from package " + packageName);
          sources.addPackage(packageName);
        }
        packages.add(packageName);
        int i = packageName.lastIndexOf('.');
        if (i < 0)
          packageName = null;
        else
          packageName = packageName.substring(0,i);
      }
    }
    catch (Exception e)
    {
      getLog().error("Error while adding the annotated class " + name, e);
      throw new MojoFailureException(e.getMessage());
    }
  }

  private ParsedPersistenceXmlDescriptor loadPersistenceUnit(
      ClassLoaderService classLoaderService,
      Properties properties
      )
      throws
        MojoFailureException
  {
    PersistenceXmlParser parser =
        new PersistenceXmlParser(
            classLoaderService,
            PersistenceUnitTransactionType.RESOURCE_LOCAL
             );

    Map<String, ParsedPersistenceXmlDescriptor> units =
        parser.doResolve(properties);

    if (persistenceUnit == null)
    {
      Iterator<String> names = units.keySet().iterator();
      if (!names.hasNext())
      {
        getLog().info("Found no META-INF/persistence.xml.");
        return null;
      }

      String name = names.next();
      if (!names.hasNext())
      {
          getLog().info("Using persistence-unit " + name);
          return units.get(name);
      }

      StringBuilder builder = new StringBuilder();
      builder.append("No name provided and multiple persistence units found: ");
      builder.append(name);
      while(names.hasNext())
      {
        builder.append(", ");
        builder.append(names.next());
      }
      builder.append('.');
      throw new MojoFailureException(builder.toString());
    }

    if (units.containsKey(persistenceUnit))
    {
      getLog().info("Using configured persistence-unit " + persistenceUnit);
      return units.get(persistenceUnit);
    }

    throw new MojoFailureException("Could not find persistence-unit " + persistenceUnit);
  }


  public static void printStrackTrace(StringBuilder builder, Throwable t)
  {
    while (t != null)
    {
      builder.append("\n\tCause: ");
      builder.append(t.getMessage() == null ? "" : t.getMessage().replaceAll("\\s+", " "));
      for (StackTraceElement trace : t.getStackTrace())
      {
        builder.append("\n\t");
        builder.append(trace.getClassName());
        builder.append(".");
        builder.append(trace.getMethodName());
        builder.append("():");
        builder.append(trace.getLineNumber());
      }
      t = t.getCause();
    }
  }
}