* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* @author Tom Baeyens

*/

  private static Logger log = Logger.getLogger(ProcessEngineConfigurationImpl.class.getName());

  public static final String DB_SCHEMA_UPDATE_CREATE = "create";

  public static final String DB_SCHEMA_UPDATE_DROP_CREATE = "drop-create";

  public static final int HISTORYLEVEL_NONE = HistoryLevel.HISTORY_LEVEL_NONE.getId();

  public static final int HISTORYLEVEL_ACTIVITY = HistoryLevel.HISTORY_LEVEL_ACTIVITY.getId();

  public static final int HISTORYLEVEL_AUDIT = HistoryLevel.HISTORY_LEVEL_AUDIT.getId();

  public static final int HISTORYLEVEL_FULL = HistoryLevel.HISTORY_LEVEL_FULL.getId();

  public static final String DEFAULT_WS_SYNC_FACTORY = "org.camunda.bpm.engine.impl.webservice.CxfWebServiceClientFactory";

  public static final String DEFAULT_MYBATIS_MAPPING_FILE = "org/camunda/bpm/engine/impl/mapping/mappings.xml";

  // SERVICES /////////////////////////////////////////////////////////////////

  protected RepositoryService repositoryService = new RepositoryServiceImpl();

  protected RuntimeService runtimeService = new RuntimeServiceImpl();

  protected HistoryService historyService = new HistoryServiceImpl();

  protected IdentityService identityService = new IdentityServiceImpl();

  protected TaskService taskService = new TaskServiceImpl();

  protected FormService formService = new FormServiceImpl();

  protected ManagementService managementService = new ManagementServiceImpl();

  protected AuthorizationService authorizationService = new AuthorizationServiceImpl();

  protected CaseService caseService = new CaseServiceImpl();

  protected FilterService filterService = new FilterServiceImpl();

  // COMMAND EXECUTORS ////////////////////////////////////////////////////////

  // Command executor and interceptor stack

  /** the configurable list which will be {@link #initInterceptorChain(java.util.List) processed} to build the {@link #commandExecutorTxRequired} */

  protected List<CommandInterceptor> customPreCommandInterceptorsTxRequired;

  protected List<CommandInterceptor> customPostCommandInterceptorsTxRequired;

  protected List<CommandInterceptor> commandInterceptorsTxRequired;

  /** this will be initialized during the configurationComplete() */

  protected CommandExecutor commandExecutorTxRequired;

  /** the configurable list which will be {@link #initInterceptorChain(List) processed} to build the {@link #commandExecutorTxRequiresNew} */

  protected List<CommandInterceptor> customPreCommandInterceptorsTxRequiresNew;

  protected List<CommandInterceptor> customPostCommandInterceptorsTxRequiresNew;

  protected List<CommandInterceptor> commandInterceptorsTxRequiresNew;

  /** this will be initialized during the configurationComplete() */

  protected CommandExecutor commandExecutorTxRequiresNew;

  /** Separate command executor to be used for db schema operations. Must always use NON-JTA transactions */

  protected CommandExecutor commandExecutorSchemaOperations;

  // SESSION FACTORIES ////////////////////////////////////////////////////////

  protected List<SessionFactory> customSessionFactories;

  protected DbSqlSessionFactory dbSqlSessionFactory;

  protected Map<Class<?>, SessionFactory> sessionFactories;

  // DEPLOYERS ////////////////////////////////////////////////////////////////

  protected List<Deployer> customPreDeployers;

  protected List<Deployer> customPostDeployers;

  protected List<Deployer> deployers;

  protected DeploymentCache deploymentCache;

  // JOB EXECUTOR /////////////////////////////////////////////////////////////

  protected List<JobHandler> customJobHandlers;

  protected Map<String, JobHandler> jobHandlers;

  protected JobExecutor jobExecutor;

  // MYBATIS SQL SESSION FACTORY //////////////////////////////////////////////

  protected SqlSessionFactory sqlSessionFactory;

  protected TransactionFactory transactionFactory;

  // ID GENERATOR /////////////////////////////////////////////////////////////

  protected IdGenerator idGenerator;

  protected DataSource idGeneratorDataSource;

  protected String idGeneratorDataSourceJndiName;

  // INCIDENT HANDLER /////////////////////////////////////////////////////////

  protected Map<String, IncidentHandler> incidentHandlers;

  protected List<IncidentHandler> customIncidentHandlers;

  // OTHER ////////////////////////////////////////////////////////////////////

  protected List<FormEngine> customFormEngines;

  protected Map<String, FormEngine> formEngines;

  protected List<AbstractFormFieldType> customFormTypes;

  protected FormTypes formTypes;

  protected FormValidators formValidators;

  protected Map<String, Class<? extends FormFieldValidator>> customFormFieldValidators;

  protected List<TypedValueSerializer> customPreVariableSerializers;

  protected List<TypedValueSerializer> customPostVariableSerializers;

  protected VariableSerializers variableSerializers;

  protected String defaultSerializationFormat = JavaObjectSerializer.SERIALIZATION_DATA_FORMAT;

  protected String defaultCharsetName = null;

  protected Charset defaultCharset = null;

  protected ExpressionManager expressionManager;

  protected List<String> customScriptingEngineClasses;

  protected ScriptingEngines scriptingEngines;

  protected List<ResolverFactory> resolverFactories;

  protected ScriptingEnvironment scriptingEnvironment;

  protected List<ScriptEnvResolver> scriptEnvResolvers;

  protected ScriptFactory scriptFactory;

  protected boolean autoStoreScriptVariables = false;

  protected boolean enableScriptCompilation = true;

  protected boolean cmmnEnabled = true;

  protected BusinessCalendarManager businessCalendarManager;

  protected String wsSyncFactoryClassName = DEFAULT_WS_SYNC_FACTORY;

  protected CommandContextFactory commandContextFactory;

  protected TransactionContextFactory transactionContextFactory;

  protected BpmnParseFactory bpmnParseFactory;

  // cmmn

  protected CmmnTransformFactory cmmnTransformFactory;

  protected DefaultCmmnElementHandlerRegistry cmmnElementHandlerRegistry;

  protected HistoryLevel historyLevel;

  /** a list of supported history levels */

  protected List<HistoryLevel> historyLevels;

  /** a list of supported custom history levels */

  protected List<HistoryLevel> customHistoryLevels;

  protected List<BpmnParseListener> preParseListeners;

  protected List<BpmnParseListener> postParseListeners;

  protected List<CmmnTransformListener> customPreCmmnTransformListeners;

  protected List<CmmnTransformListener> customPostCmmnTransformListeners;

  protected Map<Object, Object> beans;

  protected boolean isDbIdentityUsed = true;

  protected boolean isDbHistoryUsed = true;

  protected DelegateInterceptor delegateInterceptor;

  protected CommandInterceptor actualCommandExecutor;

  protected RejectedJobsHandler customRejectedJobsHandler;

  protected Map<String, EventHandler> eventHandlers;

  protected List<EventHandler> customEventHandlers;

  protected FailedJobCommandFactory failedJobCommandFactory;

  protected String databaseTablePrefix = "";

  /**

   * In some situations you want to set the schema to use for table checks / generation if the database metadata

   * doesn't return that correctly, see https://jira.codehaus.org/browse/ACT-1220,

   * https://jira.codehaus.org/browse/ACT-1062

   */

  protected String databaseSchema = null;

  protected boolean isCreateDiagramOnDeploy = false;

  protected ProcessApplicationManager processApplicationManager;

  protected CorrelationHandler correlationHandler;

  /** session factory to be used for obtaining identity provider sessions */

  protected SessionFactory identityProviderSessionFactory;

  protected PasswordEncryptor passwordEncryptor;

  protected Set<String> registeredDeployments;

  protected ResourceAuthorizationProvider resourceAuthorizationProvider;

  protected List<ProcessEnginePlugin> processEnginePlugins = new ArrayList<ProcessEnginePlugin>();

  protected HistoryEventProducer historyEventProducer;

  protected CmmnHistoryEventProducer cmmnHistoryEventProducer;

  protected HistoryEventHandler historyEventHandler;

  protected boolean isExecutionTreePrefetchEnabled = true;

  /** If true the process engine will attempt to acquire an exclusive lock before

   * creating a deployment.

   */

  protected boolean isDeploymentLockUsed = true;

  /** Allows setting whether the process engine should try reusing the first level entity cache.

   * Default setting is false, enabling it improves performance of asynchronous continuations.

   */

  protected boolean isDbEntityCacheReuseEnabled = false;

  protected boolean isInvokeCustomVariableListeners = true;

  /**

   * The process engine created by this configuration.

   */

  protected ProcessEngineImpl processEngine;

  /** used to create instances for listeners, JavaDelegates, etc */

  protected ArtifactFactory artifactFactory;

  protected DbEntityCacheKeyMapping dbEntityCacheKeyMapping = DbEntityCacheKeyMapping.defaultEntityCacheKeyMapping();

  // buildProcessEngine ///////////////////////////////////////////////////////

  public ProcessEngine buildProcessEngine() {

    init();

    processEngine = new ProcessEngineImpl(this);

    invokePostProcessEngineBuild(processEngine);

    return processEngine;

  }

  // init /////////////////////////////////////////////////////////////////////

  protected void init() {

    invokePreInit();

    initDefaultCharset();

    initHistoryLevel();

    initHistoryEventProducer();

    initCmmnHistoryEventProducer();

    initHistoryEventHandler();

    initExpressionManager();

    initBeans();

    initArtifactFactory();

    initFormEngines();

    initFormTypes();

    initFormFieldValidators();

    initScripting();

    initBusinessCalendarManager();

    initCommandContextFactory();

    initTransactionContextFactory();

    initCommandExecutors();

    initServices();

    initIdGenerator();

    initDeployers();

    initJobExecutor();

    initDataSource();

    initTransactionFactory();

    initSqlSessionFactory();

    initIdentityProviderSessionFactory();

    initSessionFactories();

    initValueTypeResolver();

    initSerialization();

    initJpa();

    initDelegateInterceptor();

    initEventHandlers();

    initFailedJobCommandFactory();

    initProcessApplicationManager();

    initCorrelationHandler();

    initIncidentHandlers();

    initPasswordDigest();

    initDeploymentRegistration();

    initResourceAuthorizationProvider();

    invokePostInit();

  }

  protected void invokePreInit() {

    for (ProcessEnginePlugin plugin : processEnginePlugins) {

      log.log(Level.INFO, "PLUGIN {0} activated on process engine {1}",

          new String[]{plugin.getClass().getSimpleName(),

          getProcessEngineName()});

      plugin.preInit(this);

    }

  }

  protected void invokePostInit() {

    for (ProcessEnginePlugin plugin : processEnginePlugins) {

      plugin.postInit(this);

    }

  }

  protected void invokePostProcessEngineBuild(ProcessEngine engine) {

    for (ProcessEnginePlugin plugin : processEnginePlugins) {

      plugin.postProcessEngineBuild(engine);

    }

  }

  // failedJobCommandFactory ////////////////////////////////////////////////////////

  protected void initFailedJobCommandFactory() {

    if (failedJobCommandFactory == null) {

      failedJobCommandFactory = new DefaultFailedJobCommandFactory();

    }

  }

  // incident handlers /////////////////////////////////////////////////////////////

  protected void initIncidentHandlers() {

    if (incidentHandlers == null) {

      incidentHandlers = new HashMap<String, IncidentHandler>();

      FailedJobIncidentHandler failedJobIncidentHandler = new FailedJobIncidentHandler();

      incidentHandlers.put(failedJobIncidentHandler.getIncidentHandlerType(), failedJobIncidentHandler);

    }

    if(customIncidentHandlers != null) {

      for (IncidentHandler incidentHandler : customIncidentHandlers) {

        incidentHandlers.put(incidentHandler.getIncidentHandlerType(), incidentHandler);

      }

    }

  }

  // command executors ////////////////////////////////////////////////////////

  protected abstract Collection< ? extends CommandInterceptor> getDefaultCommandInterceptorsTxRequired();

  protected abstract Collection< ? extends CommandInterceptor> getDefaultCommandInterceptorsTxRequiresNew();

  protected void initCommandExecutors() {

    initActualCommandExecutor();

    initCommandInterceptorsTxRequired();

    initCommandExecutorTxRequired();

    initCommandInterceptorsTxRequiresNew();

    initCommandExecutorTxRequiresNew();

    initCommandExecutorDbSchemaOperations();

  }

  protected void initActualCommandExecutor() {

    actualCommandExecutor = new CommandExecutorImpl();

  }

  protected void initCommandInterceptorsTxRequired() {

    if (commandInterceptorsTxRequired==null) {

      if (customPreCommandInterceptorsTxRequired!=null) {

        commandInterceptorsTxRequired = new ArrayList<CommandInterceptor>(customPreCommandInterceptorsTxRequired);

      } else {

        commandInterceptorsTxRequired = new ArrayList<CommandInterceptor>();

      }

      commandInterceptorsTxRequired.addAll(getDefaultCommandInterceptorsTxRequired());

      if (customPostCommandInterceptorsTxRequired!=null) {

        commandInterceptorsTxRequired.addAll(customPostCommandInterceptorsTxRequired);

      }

      commandInterceptorsTxRequired.add(actualCommandExecutor);

    }

  }

  protected void initCommandInterceptorsTxRequiresNew() {

    if (commandInterceptorsTxRequiresNew==null) {

      if (customPreCommandInterceptorsTxRequiresNew!=null) {

        commandInterceptorsTxRequiresNew = new ArrayList<CommandInterceptor>(customPreCommandInterceptorsTxRequiresNew);

      } else {

        commandInterceptorsTxRequiresNew = new ArrayList<CommandInterceptor>();

      }

      commandInterceptorsTxRequiresNew.addAll(getDefaultCommandInterceptorsTxRequiresNew());

      if (customPostCommandInterceptorsTxRequiresNew!=null) {

        commandInterceptorsTxRequiresNew.addAll(customPostCommandInterceptorsTxRequiresNew);

      }

      commandInterceptorsTxRequiresNew.add(actualCommandExecutor);

    }

  }

  protected void initCommandExecutorTxRequired() {

    if (commandExecutorTxRequired==null) {

      commandExecutorTxRequired = initInterceptorChain(commandInterceptorsTxRequired);

    }

  }

  protected void initCommandExecutorTxRequiresNew() {

    if (commandExecutorTxRequiresNew==null) {

      commandExecutorTxRequiresNew = initInterceptorChain(commandInterceptorsTxRequiresNew);

    }

  }

  protected void initCommandExecutorDbSchemaOperations() {

    if (commandExecutorSchemaOperations==null) {

      // in default case, we use the same command executor for DB Schema Operations as for runtime operations.

      // configurations that Use JTA Transactions should override this method and provide a custom command executor

      // that uses NON-JTA Transactions.

      commandExecutorSchemaOperations = commandExecutorTxRequired;

    }

  }

  protected CommandInterceptor initInterceptorChain(List<CommandInterceptor> chain) {

    if (chain==null || chain.isEmpty()) {

      throw new ProcessEngineException("invalid command interceptor chain configuration: "+chain);

    }

    for (int i = 0; i < chain.size()-1; i++) {

      chain.get(i).setNext( chain.get(i+1) );

    }

    return chain.get(0);

  }

  // services /////////////////////////////////////////////////////////////////

  protected void initServices() {

    initService(repositoryService);

    initService(runtimeService);

    initService(historyService);

    initService(identityService);

    initService(taskService);

    initService(formService);

    initService(managementService);

    initService(authorizationService);

    initService(caseService);

    initService(filterService);

  }

  protected void initService(Object service) {

    if (service instanceof ServiceImpl) {

      ((ServiceImpl)service).setCommandExecutor(commandExecutorTxRequired);

    }

  }

  // DataSource ///////////////////////////////////////////////////////////////

  protected void initDataSource() {

    if (dataSource==null) {

      if (dataSourceJndiName!=null) {

        try {

          dataSource = (DataSource) new InitialContext().lookup(dataSourceJndiName);

        } catch (Exception e) {

          throw new ProcessEngineException("couldn't lookup datasource from "+dataSourceJndiName+": "+e.getMessage(), e);

        }

      } else if (jdbcUrl!=null) {

        if ( (jdbcDriver==null) || (jdbcUrl==null) || (jdbcUsername==null) ) {

          throw new ProcessEngineException("DataSource or JDBC properties have to be specified in a process engine configuration");

        }

        log.fine("initializing datasource to db: "+jdbcUrl);

        PooledDataSource pooledDataSource =

          new PooledDataSource(ReflectUtil.getClassLoader(), jdbcDriver, jdbcUrl, jdbcUsername, jdbcPassword );

        if (jdbcMaxActiveConnections > 0) {

          pooledDataSource.setPoolMaximumActiveConnections(jdbcMaxActiveConnections);

        }

        if (jdbcMaxIdleConnections > 0) {

          pooledDataSource.setPoolMaximumIdleConnections(jdbcMaxIdleConnections);

        }

        if (jdbcMaxCheckoutTime > 0) {

          pooledDataSource.setPoolMaximumCheckoutTime(jdbcMaxCheckoutTime);

        }

        if (jdbcMaxWaitTime > 0) {

          pooledDataSource.setPoolTimeToWait(jdbcMaxWaitTime);

        }

        if (jdbcPingEnabled == true) {

          pooledDataSource.setPoolPingEnabled(true);

          if (jdbcPingQuery != null) {

            pooledDataSource.setPoolPingQuery(jdbcPingQuery);

          }

          pooledDataSource.setPoolPingConnectionsNotUsedFor(jdbcPingConnectionNotUsedFor);

        }

        dataSource = pooledDataSource;

      }

      if (dataSource instanceof PooledDataSource) {

        // ACT-233: connection pool of Ibatis is not properely initialized if this is not called!

        ((PooledDataSource)dataSource).forceCloseAll();

      }

    }

    if (databaseType == null) {

      initDatabaseType();

    }

  }

  protected static Properties databaseTypeMappings = getDefaultDatabaseTypeMappings();

  protected static Properties getDefaultDatabaseTypeMappings() {

    Properties databaseTypeMappings = new Properties();

    databaseTypeMappings.setProperty("H2","h2");

    databaseTypeMappings.setProperty("MySQL","mysql");

    databaseTypeMappings.setProperty("Oracle","oracle");

    databaseTypeMappings.setProperty("PostgreSQL","postgres");

    databaseTypeMappings.setProperty("Microsoft SQL Server","mssql");

    databaseTypeMappings.setProperty("DB2","db2");

    databaseTypeMappings.setProperty("DB2","db2");

    databaseTypeMappings.setProperty("DB2/NT","db2");

    databaseTypeMappings.setProperty("DB2/NT64","db2");

    databaseTypeMappings.setProperty("DB2 UDP","db2");

    databaseTypeMappings.setProperty("DB2/LINUX","db2");

    databaseTypeMappings.setProperty("DB2/LINUX390","db2");

    databaseTypeMappings.setProperty("DB2/LINUXX8664","db2");

    databaseTypeMappings.setProperty("DB2/LINUXZ64","db2");

    databaseTypeMappings.setProperty("DB2/400 SQL","db2");

    databaseTypeMappings.setProperty("DB2/6000","db2");

    databaseTypeMappings.setProperty("DB2 UDB iSeries","db2");

    databaseTypeMappings.setProperty("DB2/AIX64","db2");

    databaseTypeMappings.setProperty("DB2/HPUX","db2");

    databaseTypeMappings.setProperty("DB2/HP64","db2");

    databaseTypeMappings.setProperty("DB2/SUN","db2");

    databaseTypeMappings.setProperty("DB2/SUN64","db2");

    databaseTypeMappings.setProperty("DB2/PTX","db2");

    databaseTypeMappings.setProperty("DB2/2","db2");

    return databaseTypeMappings;

  }

  public void initDatabaseType() {

    Connection connection = null;

    try {

      connection = dataSource.getConnection();

      DatabaseMetaData databaseMetaData = connection.getMetaData();

      String databaseProductName = databaseMetaData.getDatabaseProductName();

      log.fine("database product name: '" + databaseProductName + "'");

      databaseType = databaseTypeMappings.getProperty(databaseProductName);

      ensureNotNull("couldn't deduct database type from database product name '" + databaseProductName + "'", "databaseType", databaseType);

      log.fine("using database type: " + databaseType);

    } catch (SQLException e) {

      e.printStackTrace();

    } finally {

      try {

        if (connection!=null) {

          connection.close();

        }

      } catch (SQLException e) {

        e.printStackTrace();

      }

    }

  }

  // myBatis SqlSessionFactory ////////////////////////////////////////////////

  protected void initTransactionFactory() {

    if (transactionFactory==null) {

      if (transactionsExternallyManaged) {

        transactionFactory = new ManagedTransactionFactory();

      } else {

        transactionFactory = new JdbcTransactionFactory();

      }

    }

  }

  protected void initSqlSessionFactory() {

    if (sqlSessionFactory==null) {

      InputStream inputStream = null;

      try {

        inputStream = getMyBatisXmlConfigurationSteam();

        // update the jdbc parameters to the configured ones...

        Environment environment = new Environment("default", transactionFactory, dataSource);

        Reader reader = new InputStreamReader(inputStream);

        Properties properties = new Properties();

        properties.put("prefix", databaseTablePrefix);

        if(databaseType != null) {

          properties.put("limitBefore" , DbSqlSessionFactory.databaseSpecificLimitBeforeStatements.get(databaseType));

          properties.put("limitAfter" , DbSqlSessionFactory.databaseSpecificLimitAfterStatements.get(databaseType));

          properties.put("limitBetween" , DbSqlSessionFactory.databaseSpecificLimitBetweenStatements.get(databaseType));

          properties.put("limitBetweenClob" , DbSqlSessionFactory.databaseSpecificLimitBetweenClobStatements.get(databaseType));

          properties.put("orderBy" , DbSqlSessionFactory.databaseSpecificOrderByStatements.get(databaseType));

          properties.put("limitBeforeNativeQuery" , DbSqlSessionFactory.databaseSpecificLimitBeforeNativeQueryStatements.get(databaseType));

          properties.put("bitand1" , DbSqlSessionFactory.databaseSpecificBitAnd1.get(databaseType));

          properties.put("bitand2" , DbSqlSessionFactory.databaseSpecificBitAnd2.get(databaseType));

          properties.put("bitand3" , DbSqlSessionFactory.databaseSpecificBitAnd3.get(databaseType));

          properties.put("trueConstant", DbSqlSessionFactory.databaseSpecificTrueConstant.get(databaseType));

          properties.put("falseConstant", DbSqlSessionFactory.databaseSpecificFalseConstant.get(databaseType));

          properties.put("dbSpecificDummyTable" , DbSqlSessionFactory.databaseSpecificDummyTable.get(databaseType));

          Map<String, String> constants = DbSqlSessionFactory.dbSpecificConstants.get(databaseType);

          for (Entry<String, String> entry : constants.entrySet()) {

            properties.put(entry.getKey(), entry.getValue());

          }

        }

        XMLConfigBuilder parser = new XMLConfigBuilder(reader,"", properties);

        Configuration configuration = parser.getConfiguration();

        configuration.setEnvironment(environment);

        configuration = parser.parse();

        sqlSessionFactory = new DefaultSqlSessionFactory(configuration);

      } catch (Exception e) {

        throw new ProcessEngineException("Error while building ibatis SqlSessionFactory: " + e.getMessage(), e);

      } finally {

        IoUtil.closeSilently(inputStream);

      }

    }

  }

  protected InputStream getMyBatisXmlConfigurationSteam() {

    return ReflectUtil.getResourceAsStream(DEFAULT_MYBATIS_MAPPING_FILE);

  }

  // session factories ////////////////////////////////////////////////////////

  protected void initIdentityProviderSessionFactory() {

    if(identityProviderSessionFactory == null) {

      identityProviderSessionFactory = new GenericManagerFactory(DbIdentityServiceProvider.class);

    }

  }

  protected void initSessionFactories() {

    if (sessionFactories==null) {

      sessionFactories = new HashMap<Class<?>, SessionFactory>();