* 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

* @author Joram Barrez

*/

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

 

  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(this);

  protected IdentityService identityService = new IdentityServiceImpl();

  protected TaskService taskService = new TaskServiceImpl(this);

  protected FormService formService = new FormServiceImpl();

  protected ManagementService managementService = new ManagementServiceImpl();

 

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

 

  protected CommandConfig defaultCommandConfig;

  protected CommandConfig schemaCommandConfig;

 

  protected CommandInterceptor commandInvoker;

 

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

  protected List<CommandInterceptor> customPreCommandInterceptors;

  protected List<CommandInterceptor> customPostCommandInterceptors;

 

  protected List<CommandInterceptor> commandInterceptors;

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

  protected CommandExecutor commandExecutor;

 

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

  protected List<SessionFactory> customSessionFactories;

  protected DbSqlSessionFactory dbSqlSessionFactory;

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

 

  // Configurators ////////////////////////////////////////////////////////////

 

  protected boolean enableConfiguratorServiceLoader = true; // Enabled by default. In certain environments this should be set to false (eg osgi)

  protected List<ProcessEngineConfigurator> configurators; // The injected configurators

  protected List<ProcessEngineConfigurator> allConfigurators; // Including auto-discovered configurators

 

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

  protected BpmnDeployer bpmnDeployer;

  protected BpmnParser bpmnParser;

  protected List<Deployer> customPreDeployers;

  protected List<Deployer> customPostDeployers;

  protected List<Deployer> deployers;

  protected DeploymentManager deploymentManager;

 

  protected int processDefinitionCacheLimit = -1; // By default, no limit

  protected DeploymentCache<ProcessDefinitionEntity> processDefinitionCache;

 

  protected int knowledgeBaseCacheLimit = -1;

  protected DeploymentCache<Object> knowledgeBaseCache;

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

 

  protected List<JobHandler> customJobHandlers;

  protected Map<String, JobHandler> jobHandlers;

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

 

  protected SqlSessionFactory sqlSessionFactory;

  protected TransactionFactory transactionFactory;

 

  protected Set<Class<?>> customMybatisMappers;

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

 

  protected IdGenerator idGenerator;

  protected DataSource idGeneratorDataSource;

  protected String idGeneratorDataSourceJndiName;

 

  // BPMN PARSER //////////////////////////////////////////////////////////////

 

  protected List<BpmnParseHandler> preBpmnParseHandlers;

  protected List<BpmnParseHandler> postBpmnParseHandlers;

  protected List<BpmnParseHandler> customDefaultBpmnParseHandlers;

  protected ActivityBehaviorFactory activityBehaviorFactory;

  protected ListenerFactory listenerFactory;

  protected BpmnParseFactory bpmnParseFactory;

 

  // PROCESS VALIDATION

 

  protected ProcessValidator processValidator;

  // 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 Map<Object, Object> beans;

 

  protected DelegateInterceptor delegateInterceptor;

  protected RejectedJobsHandler customRejectedJobsHandler;

 

  protected Map<String, EventHandler> eventHandlers;

  protected List<EventHandler> customEventHandlers;

  protected FailedJobCommandFactory failedJobCommandFactory;

 

  /**

   * Set this to true if you want to have extra checks on the BPMN xml that is parsed.

   * See http://www.jorambarrez.be/blog/2013/02/19/uploading-a-funny-xml-can-bring-down-your-server/

   *

   * Unfortunately, this feature is not available on some platforms (JDK 6, JBoss),

   * hence the reason why it is disabled by default. If your platform allows

   * the use of StaxSource during XML parsing, do enable it.

   */

  protected boolean enableSafeBpmnXml = false;

 

  /**

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

 

  /**

   * Experimental setting. Default is false.

   *

   * If set to true, in the {@link DbSqlSession} during the handling of delete operations,

   * those operations of the same type are merged together.

   * (eg if you have two 'DELETE from X where id=Y' and 'DELETE from X where id=W', it will be merged

   * into one delete statement 'DELETE from X where id=Y or id=W'.

   */

  protected boolean isOptimizeDeleteOperationsEnabled;

 

  protected boolean enableEventDispatcher = true;

  protected ActivitiEventDispatcher eventDispatcher;

  protected List<ActivitiEventListener> eventListeners;

  protected Map<String, List<ActivitiEventListener>> typedEventListeners;

 

  // Event logging to database

  protected boolean enableDatabaseEventLogging = false;

 

 

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

 

  public ProcessEngine buildProcessEngine() {

    init();

    return new ProcessEngineImpl(this);

  }

 

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

 

  protected void init() {

    initConfigurators();

    configuratorsBeforeInit();

    initProcessDiagramGenerator();

    initHistoryLevel();

    initExpressionManager();

    initVariableTypes();

    initBeans();

    initFormEngines();

    initFormTypes();

    initScriptingEngines();

    initClock();

    initBusinessCalendarManager();

    initCommandContextFactory();

    initTransactionContextFactory();

    initCommandExecutors();

    initServices();

    initIdGenerator();

    initDeployers();

    initJobHandlers();

    initJobExecutor();

    initAsyncExecutor();

    initDataSource();

    initTransactionFactory();

    initSqlSessionFactory();

    initSessionFactories();

    initJpa();

    initDelegateInterceptor();

    initEventHandlers();

    initFailedJobCommandFactory();

    initEventDispatcher();

    initProcessValidator();

    initDatabaseEventLogging();

    configuratorsAfterInit();

  }

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

 

  protected void initFailedJobCommandFactory() {

    if (failedJobCommandFactory == null) {

      failedJobCommandFactory = new DefaultFailedJobCommandFactory();

    }

  }

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

 

  protected void initCommandExecutors() {

    initDefaultCommandConfig();

    initSchemaCommandConfig();

    initCommandInvoker();

    initCommandInterceptors();

    initCommandExecutor();

  }

  protected void initDefaultCommandConfig() {

    if (defaultCommandConfig==null) {

      defaultCommandConfig = new CommandConfig();

    }

  }

  private void initSchemaCommandConfig() {

    if (schemaCommandConfig==null) {

      schemaCommandConfig = new CommandConfig().transactionNotSupported();

    }

  }

  protected void initCommandInvoker() {

    if (commandInvoker==null) {

      commandInvoker = new CommandInvoker();

    }

  }

 

  protected void initCommandInterceptors() {

    if (commandInterceptors==null) {

      commandInterceptors = new ArrayList<CommandInterceptor>();

      if (customPreCommandInterceptors!=null) {

        commandInterceptors.addAll(customPreCommandInterceptors);

      }

      commandInterceptors.addAll(getDefaultCommandInterceptors());

      if (customPostCommandInterceptors!=null) {

        commandInterceptors.addAll(customPostCommandInterceptors);

      }

      commandInterceptors.add(commandInvoker);

    }

  }

  protected Collection< ? extends CommandInterceptor> getDefaultCommandInterceptors() {

    List<CommandInterceptor> interceptors = new ArrayList<CommandInterceptor>();

    interceptors.add(new LogInterceptor());

   

    CommandInterceptor transactionInterceptor = createTransactionInterceptor();

    if (transactionInterceptor != null) {

      interceptors.add(transactionInterceptor);

    }

   

    interceptors.add(new CommandContextInterceptor(commandContextFactory, this));

    return interceptors;

  }

  protected void initCommandExecutor() {

    if (commandExecutor==null) {

      CommandInterceptor first = initInterceptorChain(commandInterceptors);

      commandExecutor = new CommandExecutorImpl(getDefaultCommandConfig(), first);

    }

  }

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

  }

 

  protected abstract CommandInterceptor createTransactionInterceptor();

 

  // 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(commandExecutor);

    }

  }

 

  // 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.debug("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);

        }

        if (jdbcDefaultTransactionIsolationLevel > 0) {

          pooledDataSource.setDefaultTransactionIsolationLevel(jdbcDefaultTransactionIsolationLevel);

        }

        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();

 

  public static final String DATABASE_TYPE_H2 = "h2";

  public static final String DATABASE_TYPE_MYSQL = "mysql";

  public static final String DATABASE_TYPE_ORACLE = "oracle";

  public static final String DATABASE_TYPE_POSTGRES = "postgres";

  public static final String DATABASE_TYPE_MSSQL = "mssql";

  public static final String DATABASE_TYPE_DB2 = "db2";

  protected static Properties getDefaultDatabaseTypeMappings() {

    Properties databaseTypeMappings = new Properties();

    databaseTypeMappings.setProperty("H2", DATABASE_TYPE_H2);

    databaseTypeMappings.setProperty("MySQL", DATABASE_TYPE_MYSQL);

    databaseTypeMappings.setProperty("Oracle", DATABASE_TYPE_ORACLE);

    databaseTypeMappings.setProperty("PostgreSQL", DATABASE_TYPE_POSTGRES);

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

    databaseTypeMappings.setProperty(DATABASE_TYPE_DB2,DATABASE_TYPE_DB2);

    databaseTypeMappings.setProperty(DATABASE_TYPE_DB2,DATABASE_TYPE_DB2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    databaseTypeMappings.setProperty("DB2 UDB AS400", DATABASE_TYPE_DB2);

    return databaseTypeMappings;

  }

  public void initDatabaseType() {

    Connection connection = null;

    try {

      connection = dataSource.getConnection();

      DatabaseMetaData databaseMetaData = connection.getMetaData();

      String databaseProductName = databaseMetaData.getDatabaseProductName();

      log.debug("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.debug("using database type: {}", databaseType);

    } catch (SQLException e) {

      log.error("Exception while initializing Database connection", e);

    } finally {

      try {

        if (connection!=null) {

          connection.close();

        }

      } catch (SQLException e) {

          log.error("Exception while closing the Database connection", e);

      }

    }

  }

 

  // 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("limitOuterJoinBetween" , DbSqlSessionFactory.databaseOuterJoinLimitBetweenStatements.get(databaseType));

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

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

        }

       

        Configuration configuration = initMybatisConfiguration(environment, reader, properties);

        sqlSessionFactory = new DefaultSqlSessionFactory(configuration);

      } catch (Exception e) {

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

      } finally {

        IoUtil.closeSilently(inputStream);

      }

    }

  }

  protected Configuration initMybatisConfiguration(Environment environment, Reader reader, Properties properties) {

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

    Configuration configuration = parser.getConfiguration();

    configuration.setEnvironment(environment);

   

    initMybatisTypeHandlers(configuration);

    initCustomMybatisMappers(configuration);

   

    configuration = parseMybatisConfiguration(configuration, parser);

    return configuration;

  }

  protected void initMybatisTypeHandlers(Configuration configuration) {

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

  }

  protected void initCustomMybatisMappers(Configuration configuration) {

    if (getCustomMybatisMappers() != null) {

      for (Class<?> clazz : getCustomMybatisMappers()) {

        configuration.addMapper(clazz);

      }

    }

  }

 

  protected Configuration parseMybatisConfiguration(Configuration configuration, XMLConfigBuilder parser) {

    return parser.parse();

  }

 

  protected InputStream getMyBatisXmlConfigurationSteam() {

    return ReflectUtil.getResourceAsStream(DEFAULT_MYBATIS_MAPPING_FILE);

  }

 

  public Set<Class<?>> getCustomMybatisMappers() {

  return customMybatisMappers;

  }

  public void setCustomMybatisMappers(Set<Class<?>> customMybatisMappers) {

  this.customMybatisMappers = customMybatisMappers;

  }

 

  // 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.setTablePrefixIsSchema(tablePrefixIsSchema);

      dbSqlSessionFactory.setDatabaseCatalog(databaseCatalog);

      dbSqlSessionFactory.setDatabaseSchema(databaseSchema);

      dbSqlSessionFactory.setOptimizeDeleteOperationsEnabled(isOptimizeDeleteOperationsEnabled);

      addSessionFactory(dbSqlSessionFactory);

     

      addSessionFactory(new GenericManagerFactory(AttachmentEntityManager.class));

      addSessionFactory(new GenericManagerFactory(CommentEntityManager.class));

      addSessionFactory(new GenericManagerFactory(DeploymentEntityManager.class));

      addSessionFactory(new GenericManagerFactory(ModelEntityManager.class));

      addSessionFactory(new GenericManagerFactory(ExecutionEntityManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricActivityInstanceEntityManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricDetailEntityManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricProcessInstanceEntityManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricVariableInstanceEntityManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricTaskInstanceEntityManager.class));

      addSessionFactory(new GenericManagerFactory(HistoricIdentityLinkEntityManager.class));

      addSessionFactory(new GenericManagerFactory(IdentityInfoEntityManager.class));

      addSessionFactory(new GenericManagerFactory(IdentityLinkEntityManager.class));

      addSessionFactory(new GenericManagerFactory(JobEntityManager.class));

      addSessionFactory(new GenericManagerFactory(ProcessDefinitionEntityManager.class));

      addSessionFactory(new GenericManagerFactory(PropertyEntityManager.class));

      addSessionFactory(new GenericManagerFactory(ResourceEntityManager.class));

      addSessionFactory(new GenericManagerFactory(ByteArrayEntityManager.class));

      addSessionFactory(new GenericManagerFactory(TableDataManager.class));

      addSessionFactory(new GenericManagerFactory(TaskEntityManager.class));

      addSessionFactory(new GenericManagerFactory(VariableInstanceEntityManager.class));

      addSessionFactory(new GenericManagerFactory(EventSubscriptionEntityManager.class));

      addSessionFactory(new GenericManagerFactory(EventLogEntryEntityManager.class));

     

      addSessionFactory(new DefaultHistoryManagerSessionFactory());

     

      addSessionFactory(new UserEntityManagerFactory());

      addSessionFactory(new GroupEntityManagerFactory());

      addSessionFactory(new MembershipEntityManagerFactory());

    }

   

    if (customSessionFactories!=null) {

      for (SessionFactory sessionFactory: customSessionFactories) {

        addSessionFactory(sessionFactory);

      }

    }

  }

 

  protected void addSessionFactory(SessionFactory sessionFactory) {

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

  }

 

  protected void initConfigurators() {

   

    allConfigurators = new ArrayList<ProcessEngineConfigurator>();

   

    // Configurators that are explicitely added to the config

    if (configurators != null) {

      for (ProcessEngineConfigurator configurator : configurators) {

        allConfigurators.add(configurator);

      }

    }

   

    // Auto discovery through ServiceLoader

    if (enableConfiguratorServiceLoader) {

      ClassLoader classLoader = getClassLoader();

      if (classLoader == null) {

        classLoader = ReflectUtil.getClassLoader();

      }

     

      ServiceLoader<ProcessEngineConfigurator> configuratorServiceLoader

          = ServiceLoader.load(ProcessEngineConfigurator.class, classLoader);

      int nrOfServiceLoadedConfigurators = 0;

      for (ProcessEngineConfigurator configurator : configuratorServiceLoader) {

        allConfigurators.add(configurator);

        nrOfServiceLoadedConfigurators++;

      }

     

      if (nrOfServiceLoadedConfigurators > 0) {

        log.info("Found {} auto-discoverable Process Engine Configurator{}", nrOfServiceLoadedConfigurators++, nrOfServiceLoadedConfigurators > 1 ? "s" : "");

      }

     

      if (!allConfigurators.isEmpty()) {

       

        // Order them according to the priorities (usefule for dependent configurator)

        Collections.sort(allConfigurators, new Comparator<ProcessEngineConfigurator>() {

          @Override

          public int compare(ProcessEngineConfigurator configurator1, ProcessEngineConfigurator configurator2) {

            int priority1 = configurator1.getPriority();

            int priority2 = configurator2.getPriority();

           

            if (priority1 < priority2) {

              return -1;

            } else if (priority1 > priority2) {

              return 1;

            }

            return 0;

          }

        });

       

        // Execute the configurators

        log.info("Found {} Process Engine Configurators in total:", allConfigurators.size());

        for (ProcessEngineConfigurator configurator : allConfigurators) {

          log.info("{} (priority:{})", configurator.getClass(), configurator.getPriority());

        }

       

      }

     

    }

  }

 

  protected void configuratorsBeforeInit() {

    for (ProcessEngineConfigurator configurator : allConfigurators) {

      log.info("Executing beforeInit() of {} (priority:{})", configurator.getClass(), configurator.getPriority());

      configurator.beforeInit(this);

    }

  }

 

  protected void configuratorsAfterInit() {

    for (ProcessEngineConfigurator configurator : allConfigurators) {

      log.info("Executing configure() of {} (priority:{})", configurator.getClass(), configurator.getPriority());

      configurator.configure(this);

    }

  }

 

  // 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 (deploymentManager==null) {

      deploymentManager = new DeploymentManager();

      deploymentManager.setDeployers(deployers);

     

      // Process Definition cache

      if (processDefinitionCache == null) {

        if (processDefinitionCacheLimit <= 0) {

          processDefinitionCache = new DefaultDeploymentCache<ProcessDefinitionEntity>();

        } else {

          processDefinitionCache = new DefaultDeploymentCache<ProcessDefinitionEntity>(processDefinitionCacheLimit);

        }

      }

     

      // Knowledge base cache (used for Drools business task)

      if (knowledgeBaseCache == null) {

        if (knowledgeBaseCacheLimit <= 0) {

          knowledgeBaseCache = new DefaultDeploymentCache<Object>();

        } else {

          knowledgeBaseCache = new DefaultDeploymentCache<Object>(knowledgeBaseCacheLimit);

        }

      }

     

      deploymentManager.setProcessDefinitionCache(processDefinitionCache);

      deploymentManager.setKnowledgeBaseCache(knowledgeBaseCache);

    }

  }

  protected Collection< ? extends Deployer> getDefaultDeployers() {

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

    if (bpmnDeployer == null) {

      bpmnDeployer = new BpmnDeployer();

    }

     

    bpmnDeployer.setExpressionManager(expressionManager);

    bpmnDeployer.setIdGenerator(idGenerator);

   

    if (bpmnParseFactory == null) {

      bpmnParseFactory = new DefaultBpmnParseFactory();

    }

   

  if (activityBehaviorFactory == null) {

    DefaultActivityBehaviorFactory defaultActivityBehaviorFactory = new DefaultActivityBehaviorFactory();

    defaultActivityBehaviorFactory.setExpressionManager(expressionManager);

    activityBehaviorFactory = defaultActivityBehaviorFactory;

  } else if ((activityBehaviorFactory instanceof AbstractBehaviorFactory)

      && ((AbstractBehaviorFactory) activityBehaviorFactory).getExpressionManager() == null) {

    ((AbstractBehaviorFactory) activityBehaviorFactory).setExpressionManager(expressionManager);

  }

  if (listenerFactory == null) {

    DefaultListenerFactory defaultListenerFactory = new DefaultListenerFactory();

    defaultListenerFactory.setExpressionManager(expressionManager);

    listenerFactory = defaultListenerFactory;

  } else if ((listenerFactory instanceof AbstractBehaviorFactory)

      && ((AbstractBehaviorFactory) listenerFactory).getExpressionManager() == null) {

    ((AbstractBehaviorFactory) listenerFactory).setExpressionManager(expressionManager);

  }

   

    if (bpmnParser == null) {

      bpmnParser = new BpmnParser();

    }

   

    bpmnParser.setExpressionManager(expressionManager);

    bpmnParser.setBpmnParseFactory(bpmnParseFactory);

    bpmnParser.setActivityBehaviorFactory(activityBehaviorFactory);

    bpmnParser.setListenerFactory(listenerFactory);

   

    List<BpmnParseHandler> parseHandlers = new ArrayList<BpmnParseHandler>();

    if(getPreBpmnParseHandlers() != null) {

      parseHandlers.addAll(getPreBpmnParseHandlers());

    }

    parseHandlers.addAll(getDefaultBpmnParseHandlers());

    if(getPostBpmnParseHandlers() != null) {

      parseHandlers.addAll(getPostBpmnParseHandlers());

    }

   

    BpmnParseHandlers bpmnParseHandlers = new BpmnParseHandlers();

    bpmnParseHandlers.addHandlers(parseHandlers);

    bpmnParser.setBpmnParserHandlers(bpmnParseHandlers);

   

    bpmnDeployer.setBpmnParser(bpmnParser);

   

    defaultDeployers.add(bpmnDeployer);

    return defaultDeployers;

  }

 

  protected List<BpmnParseHandler> getDefaultBpmnParseHandlers() {

   

    // Alpabetic list of default parse handler classes

    List<BpmnParseHandler> bpmnParserHandlers = new ArrayList<BpmnParseHandler>();

    bpmnParserHandlers.add(new BoundaryEventParseHandler());

    bpmnParserHandlers.add(new BusinessRuleParseHandler());

    bpmnParserHandlers.add(new CallActivityParseHandler());

    bpmnParserHandlers.add(new CancelEventDefinitionParseHandler());

    bpmnParserHandlers.add(new CompensateEventDefinitionParseHandler());

    bpmnParserHandlers.add(new EndEventParseHandler());

    bpmnParserHandlers.add(new ErrorEventDefinitionParseHandler());

    bpmnParserHandlers.add(new EventBasedGatewayParseHandler());

    bpmnParserHandlers.add(new ExclusiveGatewayParseHandler());

    bpmnParserHandlers.add(new InclusiveGatewayParseHandler());

    bpmnParserHandlers.add(new IntermediateCatchEventParseHandler());

    bpmnParserHandlers.add(new IntermediateThrowEventParseHandler());

    bpmnParserHandlers.add(new ManualTaskParseHandler());

    bpmnParserHandlers.add(new MessageEventDefinitionParseHandler());

    bpmnParserHandlers.add(new ParallelGatewayParseHandler());

    bpmnParserHandlers.add(new ProcessParseHandler());

    bpmnParserHandlers.add(new ReceiveTaskParseHandler());

    bpmnParserHandlers.add(new ScriptTaskParseHandler());

    bpmnParserHandlers.add(new SendTaskParseHandler());

    bpmnParserHandlers.add(new SequenceFlowParseHandler());

    bpmnParserHandlers.add(new ServiceTaskParseHandler());

    bpmnParserHandlers.add(new SignalEventDefinitionParseHandler());

    bpmnParserHandlers.add(new StartEventParseHandler());

    bpmnParserHandlers.add(new SubProcessParseHandler());

    bpmnParserHandlers.add(new EventSubProcessParseHandler());

    bpmnParserHandlers.add(new TaskParseHandler());

    bpmnParserHandlers.add(new TimerEventDefinitionParseHandler());

    bpmnParserHandlers.add(new TransactionParseHandler());

    bpmnParserHandlers.add(new UserTaskParseHandler());

   

    // Replace any default handler if the user wants to replace them

    if (customDefaultBpmnParseHandlers != null) {

     

      Map<Class<?>, BpmnParseHandler> customParseHandlerMap = new HashMap<Class<?>, BpmnParseHandler>();

      for (BpmnParseHandler bpmnParseHandler : customDefaultBpmnParseHandlers) {

        for (Class<?> handledType : bpmnParseHandler.getHandledTypes()) {

          customParseHandlerMap.put(handledType, bpmnParseHandler);

        }

      }

     

      for (int i=0; i<bpmnParserHandlers.size(); i++) {