* 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 String DEFAULT_WS_SYNC_FACTORY = "org.activiti.engine.impl.webservice.CxfWebServiceClientFactory";

 

  public static final String DEFAULT_MYBATIS_MAPPING_FILE = "org/activiti/db/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();

 

  // 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;

 

  // 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;

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

  protected List<FormEngine> customFormEngines;

  protected Map<String, FormEngine> formEngines;

  protected List<AbstractFormType> customFormTypes;

  protected FormTypes formTypes;

  protected List<VariableType> customPreVariableTypes;

  protected List<VariableType> customPostVariableTypes;

  protected VariableTypes variableTypes;

 

  protected ExpressionManager expressionManager;

  protected List<String> customScriptingEngineClasses;

  protected ScriptingEngines scriptingEngines;

  protected List<ResolverFactory> resolverFactories;

 

  protected BusinessCalendarManager businessCalendarManager;

  protected String wsSyncFactoryClassName = DEFAULT_WS_SYNC_FACTORY;

  protected CommandContextFactory commandContextFactory;

  protected TransactionContextFactory transactionContextFactory;

  protected BpmnParseFactory bpmnParseFactory;

 

  protected HistoryLevel historyLevel;

 

  protected List<BpmnParseListener> preParseListeners;

  protected List<BpmnParseListener> postParseListeners;

  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 = "";

 

  /**

   * The following settings will determine the amount of entities loaded at once when the engine

   * needs to load multiple entities (eg. when suspending a process definition with all its process instances).

   *

   * The default setting is quite low, as not to surprise anyone with sudden memory spikes.

   * Change it to something higher if the environment Activiti runs in allows it.

   */

  protected int batchSizeProcessInstances = 25;

  protected int batchSizeTasks = 25;

 

  /**

   * 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 = true;

 

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

 

  public ProcessEngine buildProcessEngine() {

    init();

    return new ProcessEngineImpl(this);

  }

 

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

 

  protected void init() {

    initHistoryLevel();

    initExpressionManager();

    initVariableTypes();

    initBeans();

    initFormEngines();

    initFormTypes();

    initScriptingEngines();

    initBusinessCalendarManager();

    initCommandContextFactory();

    initTransactionContextFactory();

    initCommandExecutors();

    initServices();

    initIdGenerator();

    initDeployers();

    initJobExecutor();

    initDataSource();

    initTransactionFactory();

    initSqlSessionFactory();

    initSessionFactories();

    initJpa();

    initDelegateInterceptor();

    initEventHandlers();

    initFailedJobCommandFactory();

  }

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

 

  protected void initFailedJobCommandFactory() {

    if (failedJobCommandFactory == null) {

      failedJobCommandFactory = new DefaultFailedJobCommandFactory();

    }

  }

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

 

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

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

 

  protected void initCommandExecutors() {

    initActualCommandExecutor();

    initCommandInterceptorsTxRequired();

    initCommandExecutorTxRequired();

    initCommandInterceptorsTxRequiresNew();

    initCommandExecutorTxRequiresNew();

  }

  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 CommandInterceptor initInterceptorChain(List<CommandInterceptor> chain) {

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

      throw new ActivitiException("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);

  }

  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 ActivitiException("couldn't lookup datasource from "+dataSourceJndiName+": "+e.getMessage(), e);

        }

       

      } else if (jdbcUrl!=null) {

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

          throw new ActivitiException("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);

      if (databaseType==null) {

        throw new ActivitiException("couldn't deduct database type from database product name '"+databaseProductName+"'");

      }

      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("orderBy" , DbSqlSessionFactory.databaseSpecificOrderByStatements.get(databaseType));

        }

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

        Configuration configuration = parser.getConfiguration();

        configuration.setEnvironment(environment);

        configuration.getTypeHandlerRegistry().register(VariableType.class, JdbcType.VARCHAR, new IbatisVariableTypeHandler());

        configuration = parser.parse();

        sqlSessionFactory = new DefaultSqlSessionFactory(configuration);

      } catch (Exception e) {

        throw new ActivitiException("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 initSessionFactories() {

    if (sessionFactories==null) {

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

      dbSqlSessionFactory = new DbSqlSessionFactory();

      dbSqlSessionFactory.setDatabaseType(databaseType);

      dbSqlSessionFactory.setIdGenerator(idGenerator);

      dbSqlSessionFactory.setSqlSessionFactory(sqlSessionFactory);

      dbSqlSessionFactory.setDbIdentityUsed(isDbIdentityUsed);

      dbSqlSessionFactory.setDbHistoryUsed(isDbHistoryUsed);

      dbSqlSessionFactory.setDatabaseTablePrefix(databaseTablePrefix);

      dbSqlSessionFactory.setDatabaseSchema(databaseSchema);

      addSessionFactory(dbSqlSessionFactory);

     

      addSessionFactory(new GenericManagerFactory(AttachmentManager.class));

      addSessionFactory(new GenericManagerFactory(CommentManager.class));

      addSessionFactory(new GenericManagerFactory(DeploymentManager.class));

      addSessionFactory(new GenericManagerFactory(ModelManager.class));

      addSessionFactory(new GenericManagerFactory(ExecutionManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricActivityInstanceManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricDetailManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricProcessInstanceManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricVariableInstanceManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricTaskInstanceManager.class));

      addSessionFactory(new GenericManagerFactory(IdentityInfoManager.class));

      addSessionFactory(new GenericManagerFactory(IdentityLinkManager.class));

      addSessionFactory(new GenericManagerFactory(JobManager.class));

      addSessionFactory(new GenericManagerFactory(GroupManager.class));

      addSessionFactory(new GenericManagerFactory(MembershipManager.class));

      addSessionFactory(new GenericManagerFactory(ProcessDefinitionManager.class));

      addSessionFactory(new GenericManagerFactory(PropertyManager.class));

      addSessionFactory(new GenericManagerFactory(ResourceManager.class));

      addSessionFactory(new GenericManagerFactory(ByteArrayManager.class));

      addSessionFactory(new GenericManagerFactory(TableDataManager.class));

      addSessionFactory(new GenericManagerFactory(TaskManager.class));

      addSessionFactory(new GenericManagerFactory(UserManager.class));

      addSessionFactory(new GenericManagerFactory(VariableInstanceManager.class));

      addSessionFactory(new GenericManagerFactory(EventSubscriptionManager.class));

      addSessionFactory(new GenericManagerFactory(HistoryManager.class));

    }

    if (customSessionFactories!=null) {

      for (SessionFactory sessionFactory: customSessionFactories) {

        addSessionFactory(sessionFactory);

      }

    }

  }

 

  protected void addSessionFactory(SessionFactory sessionFactory) {

    sessionFactories.put(sessionFactory.getSessionType(), sessionFactory);

  }

 

  // deployers ////////////////////////////////////////////////////////////////

 

  protected void initDeployers() {

    if (this.deployers==null) {

      this.deployers = new ArrayList<Deployer>();

      if (customPreDeployers!=null) {

        this.deployers.addAll(customPreDeployers);

      }

      this.deployers.addAll(getDefaultDeployers());

      if (customPostDeployers!=null) {

        this.deployers.addAll(customPostDeployers);

      }

    }

    if (deploymentCache==null) {

      List<Deployer> deployers = new ArrayList<Deployer>();

      if (customPreDeployers!=null) {

        deployers.addAll(customPreDeployers);

      }

      deployers.addAll(getDefaultDeployers());

      if (customPostDeployers!=null) {

        deployers.addAll(customPostDeployers);

      }

      deploymentCache = new DeploymentCache();

      deploymentCache.setDeployers(deployers);

    }

  }

  protected Collection< ? extends Deployer> getDefaultDeployers() {

    List<Deployer> defaultDeployers = new ArrayList<Deployer>();

    BpmnDeployer bpmnDeployer = new BpmnDeployer();

    bpmnDeployer.setExpressionManager(expressionManager);

    bpmnDeployer.setIdGenerator(idGenerator);

   

    if (bpmnParseFactory == null) {

      bpmnParseFactory = new DefaultBpmnParseFactory();

    }

   

    BpmnParser bpmnParser = new BpmnParser(expressionManager, bpmnParseFactory);

   

    if(preParseListeners != null) {

      bpmnParser.getParseListeners().addAll(preParseListeners);

    }

    bpmnParser.getParseListeners().addAll(getDefaultBPMNParseListeners());

    if(postParseListeners != null) {

      bpmnParser.getParseListeners().addAll(postParseListeners);

    }

   

    bpmnDeployer.setBpmnParser(bpmnParser);

   

    defaultDeployers.add(bpmnDeployer);

    return defaultDeployers;

  }

 

  protected List<BpmnParseListener> getDefaultBPMNParseListeners() {

    List<BpmnParseListener> defaultListeners = new ArrayList<BpmnParseListener>();

    defaultListeners.add(new HistoryParseListener());

    return defaultListeners;

  }

  // job executor /////////////////////////////////////////////////////////////

 

  protected void initJobExecutor() {

    if (jobExecutor==null) {

      jobExecutor = new DefaultJobExecutor();

    }

    jobHandlers = new HashMap<String, JobHandler>();

    TimerExecuteNestedActivityJobHandler timerExecuteNestedActivityJobHandler = new TimerExecuteNestedActivityJobHandler();

    jobHandlers.put(timerExecuteNestedActivityJobHandler.getType(), timerExecuteNestedActivityJobHandler);

    TimerCatchIntermediateEventJobHandler timerCatchIntermediateEvent = new TimerCatchIntermediateEventJobHandler();

    jobHandlers.put(timerCatchIntermediateEvent.getType(), timerCatchIntermediateEvent);

    TimerStartEventJobHandler timerStartEvent = new TimerStartEventJobHandler();

    jobHandlers.put(timerStartEvent.getType(), timerStartEvent);

   

    AsyncContinuationJobHandler asyncContinuationJobHandler = new AsyncContinuationJobHandler();

    jobHandlers.put(asyncContinuationJobHandler.getType(), asyncContinuationJobHandler);

   

    ProcessEventJobHandler processEventJobHandler = new ProcessEventJobHandler();

    jobHandlers.put(processEventJobHandler.getType(), processEventJobHandler);

   

    TimerSuspendProcessDefinitionHandler suspendProcessDefinitionHandler = new TimerSuspendProcessDefinitionHandler();

    jobHandlers.put(suspendProcessDefinitionHandler.getType(), suspendProcessDefinitionHandler);

   

    TimerActivateProcessDefinitionHandler activateProcessDefinitionHandler = new TimerActivateProcessDefinitionHandler();

    jobHandlers.put(activateProcessDefinitionHandler.getType(), activateProcessDefinitionHandler);

   

    // if we have custom job handlers, register them

    if (getCustomJobHandlers()!=null) {

      for (JobHandler customJobHandler : getCustomJobHandlers()) {

        jobHandlers.put(customJobHandler.getType(), customJobHandler);     

      }

    }

    jobExecutor.setCommandExecutor(commandExecutorTxRequired);

    jobExecutor.setAutoActivate(jobExecutorActivate);

   

    if(jobExecutor.getRejectedJobsHandler() == null) {

      if(customRejectedJobsHandler != null) {

        jobExecutor.setRejectedJobsHandler(customRejectedJobsHandler);

      } else {

        jobExecutor.setRejectedJobsHandler(new CallerRunsRejectedJobsHandler());

      }

    }

   

  }

 

  // history //////////////////////////////////////////////////////////////////

 

  public void initHistoryLevel() {

    historyLevel = HistoryLevel.getHistoryLevelForKey(getHistory());

  }

 

  // id generator /////////////////////////////////////////////////////////////

 

  protected void initIdGenerator() {

    if (idGenerator==null) {

      CommandExecutor idGeneratorCommandExecutor = null;

      if (idGeneratorDataSource!=null) {

        ProcessEngineConfigurationImpl processEngineConfiguration = new StandaloneProcessEngineConfiguration();

        processEngineConfiguration.setDataSource(idGeneratorDataSource);

        processEngineConfiguration.setDatabaseSchemaUpdate(DB_SCHEMA_UPDATE_FALSE);

        processEngineConfiguration.init();

        idGeneratorCommandExecutor = processEngineConfiguration.getCommandExecutorTxRequiresNew();

      } else if (idGeneratorDataSourceJndiName!=null) {

        ProcessEngineConfigurationImpl processEngineConfiguration = new StandaloneProcessEngineConfiguration();

        processEngineConfiguration.setDataSourceJndiName(idGeneratorDataSourceJndiName);

        processEngineConfiguration.setDatabaseSchemaUpdate(DB_SCHEMA_UPDATE_FALSE);

        processEngineConfiguration.init();

        idGeneratorCommandExecutor = processEngineConfiguration.getCommandExecutorTxRequiresNew();

      } else {

        idGeneratorCommandExecutor = commandExecutorTxRequiresNew;

      }

     

      DbIdGenerator dbIdGenerator = new DbIdGenerator();

      dbIdGenerator.setIdBlockSize(idBlockSize);

      dbIdGenerator.setCommandExecutor(idGeneratorCommandExecutor);

      idGenerator = dbIdGenerator;

    }

  }

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

 

  protected void initCommandContextFactory() {

    if (commandContextFactory==null) {

      commandContextFactory = new CommandContextFactory();

      commandContextFactory.setProcessEngineConfiguration(this);

    }

  }

  protected void initTransactionContextFactory() {

    if (transactionContextFactory==null) {

      transactionContextFactory = new StandaloneMybatisTransactionContextFactory();

    }

  }

  protected void initVariableTypes() {

    if (variableTypes==null) {

      variableTypes = new DefaultVariableTypes();

      if (customPreVariableTypes!=null) {

        for (VariableType customVariableType: customPreVariableTypes) {

          variableTypes.addType(customVariableType);

        }

      }

      variableTypes.addType(new NullType());

      variableTypes.addType(new StringType());

      variableTypes.addType(new BooleanType());

      variableTypes.addType(new ShortType());

      variableTypes.addType(new IntegerType());

      variableTypes.addType(new LongType());

      variableTypes.addType(new DateType());

      variableTypes.addType(new DoubleType());

      variableTypes.addType(new ByteArrayType());

      variableTypes.addType(new SerializableType());

      variableTypes.addType(new CustomObjectType("item", ItemInstance.class));

      variableTypes.addType(new CustomObjectType("message", MessageInstance.class));

      if (customPostVariableTypes!=null) {

        for (VariableType customVariableType: customPostVariableTypes) {

          variableTypes.addType(customVariableType);

        }

      }

    }

  }

  protected void initFormEngines() {

    if (formEngines==null) {

      formEngines = new HashMap<String, FormEngine>();

      FormEngine defaultFormEngine = new JuelFormEngine();

      formEngines.put(null, defaultFormEngine); // default form engine is looked up with null

      formEngines.put(defaultFormEngine.getName(), defaultFormEngine);

    }

    if (customFormEngines!=null) {

      for (FormEngine formEngine: customFormEngines) {

        formEngines.put(formEngine.getName(), formEngine);

      }

    }

  }

  protected void initFormTypes() {

    if (formTypes==null) {

      formTypes = new FormTypes();

      formTypes.addFormType(new StringFormType());

      formTypes.addFormType(new LongFormType());

      formTypes.addFormType(new DateFormType("dd/MM/yyyy"));

      formTypes.addFormType(new BooleanFormType());

    }

    if (customFormTypes!=null) {

      for (AbstractFormType customFormType: customFormTypes) {

        formTypes.addFormType(customFormType);

      }

    }

  }

  protected void initScriptingEngines() {

    if (resolverFactories==null) {

      resolverFactories = new ArrayList<ResolverFactory>();

      resolverFactories.add(new VariableScopeResolverFactory());

      resolverFactories.add(new BeansResolverFactory());

    }

    if (scriptingEngines==null) {

      scriptingEngines = new ScriptingEngines(new ScriptBindingsFactory(resolverFactories));

    }

  }

  protected void initExpressionManager() {

    if (expressionManager==null) {

      expressionManager = new ExpressionManager(beans);

    }

  }

  protected void initBusinessCalendarManager() {

    if (businessCalendarManager==null) {

      MapBusinessCalendarManager mapBusinessCalendarManager = new MapBusinessCalendarManager();

      mapBusinessCalendarManager.addBusinessCalendar(DurationBusinessCalendar.NAME, new DurationBusinessCalendar());

      mapBusinessCalendarManager.addBusinessCalendar(DueDateBusinessCalendar.NAME, new DueDateBusinessCalendar());

      mapBusinessCalendarManager.addBusinessCalendar(CycleBusinessCalendar.NAME, new CycleBusinessCalendar());

      businessCalendarManager = mapBusinessCalendarManager;

    }

  }

 

  protected void initDelegateInterceptor() {

    if(delegateInterceptor == null) {

      delegateInterceptor = new DefaultDelegateInterceptor();

    }

  }

 

  protected void initEventHandlers() {

    if(eventHandlers == null) {

      eventHandlers = new HashMap<String, EventHandler>();

     

      SignalEventHandler signalEventHander = new SignalEventHandler();

      eventHandlers.put(signalEventHander.getEventHandlerType(), signalEventHander);

     

      CompensationEventHandler compensationEventHandler = new CompensationEventHandler();

      eventHandlers.put(compensationEventHandler.getEventHandlerType(), compensationEventHandler);

     

      MessageEventHandler messageEventHandler = new MessageEventHandler();

      eventHandlers.put(messageEventHandler.getEventHandlerType(), messageEventHandler);

     

    }

    if(customEventHandlers != null) {

      for (EventHandler eventHandler : customEventHandlers) {

        eventHandlers.put(eventHandler.getEventHandlerType(), eventHandler);       

      }

    }

  }

 

  // JPA //////////////////////////////////////////////////////////////////////

 

  protected void initJpa() {

    if(jpaPersistenceUnitName!=null) {

      jpaEntityManagerFactory = JpaHelper.createEntityManagerFactory(jpaPersistenceUnitName);

    }

    if(jpaEntityManagerFactory!=null) {

      sessionFactories.put(EntityManagerSession.class, new EntityManagerSessionFactory(jpaEntityManagerFactory, jpaHandleTransaction, jpaCloseEntityManager));

      VariableType jpaType = variableTypes.getVariableType(JPAEntityVariableType.TYPE_NAME);

      // Add JPA-type

      if(jpaType == null) {

        // We try adding the variable right before SerializableType, if available

        int serializableIndex = variableTypes.getTypeIndex(SerializableType.TYPE_NAME);

        if(serializableIndex > -1) {

          variableTypes.addType(new JPAEntityVariableType(), serializableIndex);

        } else {

          variableTypes.addType(new JPAEntityVariableType());

        }       

      }

    }

  }

 

  protected void initBeans() {

    if (beans == null) {

      beans = new HashMap<Object, Object>();

    }

  }

  // getters and setters //////////////////////////////////////////////////////

 

  public String getProcessEngineName() {

    return processEngineName;

  }

  public HistoryLevel getHistoryLevel() {

    return historyLevel;

  }

 

  public void setHistoryLevel(HistoryLevel historyLevel) {

    this.historyLevel = historyLevel;

  }

  public ProcessEngineConfigurationImpl setProcessEngineName(String processEngineName) {

    this.processEngineName = processEngineName;

    return this;

  }

 

  public List<CommandInterceptor> getCustomPreCommandInterceptorsTxRequired() {

    return customPreCommandInterceptorsTxRequired;

  }

 

  public ProcessEngineConfigurationImpl setCustomPreCommandInterceptorsTxRequired(List<CommandInterceptor> customPreCommandInterceptorsTxRequired) {

    this.customPreCommandInterceptorsTxRequired = customPreCommandInterceptorsTxRequired;

    return this;

  }

 

  public List<CommandInterceptor> getCustomPostCommandInterceptorsTxRequired() {

    return customPostCommandInterceptorsTxRequired;

  }

 

  public ProcessEngineConfigurationImpl setCustomPostCommandInterceptorsTxRequired(List<CommandInterceptor> customPostCommandInterceptorsTxRequired) {

    this.customPostCommandInterceptorsTxRequired = customPostCommandInterceptorsTxRequired;

    return this;

  }

 

  public List<CommandInterceptor> getCommandInterceptorsTxRequired() {

    return commandInterceptorsTxRequired;

  }

 

  public ProcessEngineConfigurationImpl setCommandInterceptorsTxRequired(List<CommandInterceptor> commandInterceptorsTxRequired) {

    this.commandInterceptorsTxRequired = commandInterceptorsTxRequired;

    return this;

  }

 

  public CommandExecutor getCommandExecutorTxRequired() {

    return commandExecutorTxRequired;

  }

 

  public ProcessEngineConfigurationImpl setCommandExecutorTxRequired(CommandExecutor commandExecutorTxRequired) {

    this.commandExecutorTxRequired = commandExecutorTxRequired;

    return this;

  }

 

  public List<CommandInterceptor> getCustomPreCommandInterceptorsTxRequiresNew() {

    return customPreCommandInterceptorsTxRequiresNew;

  }

 

  public ProcessEngineConfigurationImpl setCustomPreCommandInterceptorsTxRequiresNew(List<CommandInterceptor> customPreCommandInterceptorsTxRequiresNew) {

    this.customPreCommandInterceptorsTxRequiresNew = customPreCommandInterceptorsTxRequiresNew;

    return this;

  }

 

  public List<CommandInterceptor> getCustomPostCommandInterceptorsTxRequiresNew() {

    return customPostCommandInterceptorsTxRequiresNew;

  }

 

  public ProcessEngineConfigurationImpl setCustomPostCommandInterceptorsTxRequiresNew(List<CommandInterceptor> customPostCommandInterceptorsTxRequiresNew) {

    this.customPostCommandInterceptorsTxRequiresNew = customPostCommandInterceptorsTxRequiresNew;

    return this;

  }

 

  public List<CommandInterceptor> getCommandInterceptorsTxRequiresNew() {

    return commandInterceptorsTxRequiresNew;

  }

 

  public ProcessEngineConfigurationImpl setCommandInterceptorsTxRequiresNew(List<CommandInterceptor> commandInterceptorsTxRequiresNew) {

    this.commandInterceptorsTxRequiresNew = commandInterceptorsTxRequiresNew;

    return this;

  }

 

  public CommandExecutor getCommandExecutorTxRequiresNew() {

    return commandExecutorTxRequiresNew;

  }

 

  public ProcessEngineConfigurationImpl setCommandExecutorTxRequiresNew(CommandExecutor commandExecutorTxRequiresNew) {

    this.commandExecutorTxRequiresNew = commandExecutorTxRequiresNew;

    return this;

  }

 

  public RepositoryService getRepositoryService() {

    return repositoryService;

  }

 

  public ProcessEngineConfigurationImpl setRepositoryService(RepositoryService repositoryService) {

    this.repositoryService = repositoryService;

    return this;

  }

 

  public RuntimeService getRuntimeService() {

    return runtimeService;

  }

 

  public ProcessEngineConfigurationImpl setRuntimeService(RuntimeService runtimeService) {

    this.runtimeService = runtimeService;

    return this;

  }

 

  public HistoryService getHistoryService() {

    return historyService;

  }

 

  public ProcessEngineConfigurationImpl setHistoryService(HistoryService historyService) {

    this.historyService = historyService;

    return this;

  }

 

  public IdentityService getIdentityService() {

    return identityService;

  }

 

  public ProcessEngineConfigurationImpl setIdentityService(IdentityService identityService) {

    this.identityService = identityService;

    return this;

  }

 

  public TaskService getTaskService() {

    return taskService;

  }

 

  public ProcessEngineConfigurationImpl setTaskService(TaskService taskService) {

    this.taskService = taskService;

    return this;

  }

 

  public FormService getFormService() {

    return formService;

  }

 

  public ProcessEngineConfigurationImpl setFormService(FormService formService) {

    this.formService = formService;

    return this;

  }

 

  public ManagementService getManagementService() {

    return managementService;

  }

 

  public ProcessEngineConfigurationImpl setManagementService(ManagementService managementService) {

    this.managementService = managementService;

    return this;

  }

 

  public Map<Class< ? >, SessionFactory> getSessionFactories() {

    return sessionFactories;

  }

 

  public ProcessEngineConfigurationImpl setSessionFactories(Map<Class< ? >, SessionFactory> sessionFactories) {

    this.sessionFactories = sessionFactories;

    return this;

  }

 

  public List<Deployer> getDeployers() {

    return deployers;

  }

 

  public ProcessEngineConfigurationImpl setDeployers(List<Deployer> deployers) {

    this.deployers = deployers;

    return this;

  }

 

  public JobExecutor getJobExecutor() {

    return jobExecutor;

  }

 

  public ProcessEngineConfigurationImpl setJobExecutor(JobExecutor jobExecutor) {

    this.jobExecutor = jobExecutor;

    return this;

  }

 

  public IdGenerator getIdGenerator() {

    return idGenerator;

  }

 

  public ProcessEngineConfigurationImpl setIdGenerator(IdGenerator idGenerator) {

    this.idGenerator = idGenerator;

    return this;

  }

 

  public String getWsSyncFactoryClassName() {

    return wsSyncFactoryClassName;

  }

 

  public ProcessEngineConfigurationImpl setWsSyncFactoryClassName(String wsSyncFactoryClassName) {

    this.wsSyncFactoryClassName = wsSyncFactoryClassName;

    return this;

  }

 

  public Map<String, FormEngine> getFormEngines() {

    return formEngines;

  }

 

  public ProcessEngineConfigurationImpl setFormEngines(Map<String, FormEngine> formEngines) {

    this.formEngines = formEngines;

    return this;

  }

 

  public FormTypes getFormTypes() {

    return formTypes;

  }

 

  public ProcessEngineConfigurationImpl setFormTypes(FormTypes formTypes) {

    this.formTypes = formTypes;

    return this;

  }

 

  public ScriptingEngines getScriptingEngines() {

    return scriptingEngines;

  }

 

  public ProcessEngineConfigurationImpl setScriptingEngines(ScriptingEngines scriptingEngines) {

    this.scriptingEngines = scriptingEngines;

    return this;

  }

 

  public VariableTypes getVariableTypes() {

    return variableTypes;

  }

 

  public ProcessEngineConfigurationImpl setVariableTypes(VariableTypes variableTypes) {

    this.variableTypes = variableTypes;

    return this;

  }

 

  public ExpressionManager getExpressionManager() {

    return expressionManager;

  }

 

  public ProcessEngineConfigurationImpl setExpressionManager(ExpressionManager expressionManager) {

    this.expressionManager = expressionManager;

    return this;

  }

 

  public BusinessCalendarManager getBusinessCalendarManager() {

    return businessCalendarManager;

  }

 

  public ProcessEngineConfigurationImpl setBusinessCalendarManager(BusinessCalendarManager businessCalendarManager) {

    this.businessCalendarManager = businessCalendarManager;

    return this;

  }

 

  public CommandContextFactory getCommandContextFactory() {

    return commandContextFactory;

  }

 

  public ProcessEngineConfigurationImpl setCommandContextFactory(CommandContextFactory commandContextFactory) {

    this.commandContextFactory = commandContextFactory;

    return this;

  }

 

  public TransactionContextFactory getTransactionContextFactory() {

    return transactionContextFactory;

  }

 

  public ProcessEngineConfigurationImpl setTransactionContextFactory(TransactionContextFactory transactionContextFactory) {

    this.transactionContextFactory = transactionContextFactory;

    return this;

  }

 

  public List<Deployer> getCustomPreDeployers() {

    return customPreDeployers;

  }

 

  public ProcessEngineConfigurationImpl setCustomPreDeployers(List<Deployer> customPreDeployers) {

    this.customPreDeployers = customPreDeployers;

    return this;

  }

 

  public List<Deployer> getCustomPostDeployers() {

    return customPostDeployers;

  }

 

  public ProcessEngineConfigurationImpl setCustomPostDeployers(List<Deployer> customPostDeployers) {

    this.customPostDeployers = customPostDeployers;

    return this;

  }

 

  public Map<String, JobHandler> getJobHandlers() {

    return jobHandlers;

  }

 

  public ProcessEngineConfigurationImpl setJobHandlers(Map<String, JobHandler> jobHandlers) {

    this.jobHandlers = jobHandlers;