Example usage for org.apache.commons.pool.impl GenericObjectPool DEFAULT_MAX_ACTIVE

List of usage examples for org.apache.commons.pool.impl GenericObjectPool DEFAULT_MAX_ACTIVE

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.pool.impl.*
  5. GenericObjectPool
  6. DEFAULT_MAX_ACTIVE

Introduction

In this page you can find the example usage for org.apache.commons.pool.impl GenericObjectPool DEFAULT_MAX_ACTIVE.

Prototype

int DEFAULT_MAX_ACTIVE

To view the source code for org.apache.commons.pool.impl GenericObjectPool DEFAULT_MAX_ACTIVE.

Click Source Link

Document

The default cap on the total number of active instances from the pool.

Usage

From source file:com.ibm.xsp.extlib.relational.jdbc.datasource.dbcp.NSFFileJdbcDBCPProvider.java

public IJdbcResourceFactory loadConnection(Document doc, String name) throws XMLException, PoolException {

    // Common parameters
    String driver = getStringValue(doc, "/jdbc/driver", null); // $NON-NLS-1$
    String url = getStringValue(doc, "/jdbc/url", null); // $NON-NLS-1$
    String user = getStringValue(doc, "/jdbc/user", null); // $NON-NLS-1$
    String password = DOMAccessor.getStringValue(doc, "/jdbc/password"); // $NON-NLS-1$
    // dbcp pool parameters
    int minIdle = getIntValue(doc, "/jdbc/dbcp/minIdle", GenericObjectPool.DEFAULT_MIN_IDLE); // $NON-NLS-1$
    int maxIdle = getIntValue(doc, "/jdbc/dbcp/maxIdle", GenericObjectPool.DEFAULT_MAX_IDLE); // $NON-NLS-1$
    int maxActive = getIntValue(doc, "/jdbc/dbcp/maxActive", GenericObjectPool.DEFAULT_MAX_ACTIVE); // $NON-NLS-1$
    long maxWait = getLongValue(doc, "/jdbc/dbcp/maxWait", GenericObjectPool.DEFAULT_MAX_WAIT); // $NON-NLS-1$
    DbcpPoolDataSource dbcpDS = new DbcpPoolDataSource(name, driver, url, user, password, minIdle, maxIdle,
            maxActive, maxWait);//from w  ww.j a v a2  s .  co  m
    return dbcpDS;

}

From source file:com.toolsverse.etl.sql.connection.PooledAliasConnectionProvider.java

/**
 * Instantiates a new pooled alias connection provider.
 *//*from w ww.  j a  va 2 s  . com*/
public PooledAliasConnectionProvider() {
    _config = new GenericObjectPool.Config();

    _config.maxActive = Utils.str2Int(SystemConfig.instance().getSystemProperty(MAX_ACTIVE),
            GenericObjectPool.DEFAULT_MAX_ACTIVE);

    _config.whenExhaustedAction = Utils.str2Byte(
            SystemConfig.instance().getSystemProperty(WHEN_EXHAUSTED_ACTION),
            GenericObjectPool.WHEN_EXHAUSTED_GROW);

    _config.maxWait = Utils.str2Long(SystemConfig.instance().getSystemProperty(MAX_WAIT), 1000 * 30);

    _config.maxIdle = Utils.str2Int(SystemConfig.instance().getSystemProperty(MAX_IDLE),
            GenericObjectPool.DEFAULT_MAX_IDLE);

    _config.minIdle = Utils.str2Int(SystemConfig.instance().getSystemProperty(MIN_IDLE),
            GenericObjectPool.DEFAULT_MIN_IDLE);

    _config.testOnBorrow = Utils.str2Boolean(SystemConfig.instance().getSystemProperty(TEST_ON_BORROW),
            GenericObjectPool.DEFAULT_TEST_ON_BORROW);

    _config.testOnReturn = Utils.str2Boolean(SystemConfig.instance().getSystemProperty(TEST_ON_RETURN),
            GenericObjectPool.DEFAULT_TEST_ON_RETURN);

    _config.timeBetweenEvictionRunsMillis = Utils.str2Long(
            SystemConfig.instance().getSystemProperty(TIME_BETWEEN_EVICTION_RUNS_MILLIS),
            GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS);

    _config.numTestsPerEvictionRun = Utils.str2Int(
            SystemConfig.instance().getSystemProperty(NUM_TESTS_PER_EVICTION_RUN),
            GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN);

    _config.minEvictableIdleTimeMillis = Utils.str2Long(
            SystemConfig.instance().getSystemProperty(MIN_EVICTABLE_IDLE_TIME_MILLIS),
            GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS);

    _config.testWhileIdle = Utils.str2Boolean(SystemConfig.instance().getSystemProperty(TEST_WHILE_IDLE),
            GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
}

From source file:edu.illinois.enforcemop.examples.apache.pool.TestGenericObjectPool.java

public void testInvalidWhenExhaustedAction() throws Exception {
    try {/*from www.  j a v  a 2  s .c om*/
        pool.setWhenExhaustedAction(Byte.MAX_VALUE);
        fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
        // expected
    }

    try {
        ObjectPool pool = new GenericObjectPool(new SimpleFactory(), GenericObjectPool.DEFAULT_MAX_ACTIVE,
                Byte.MAX_VALUE, GenericObjectPool.DEFAULT_MAX_WAIT, GenericObjectPool.DEFAULT_MAX_IDLE, false,
                false, GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
                GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,
                GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS, false);
        assertNotNull(pool);
        fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
        // expected
    }
}

From source file:org.apache.avalon.dbcp.DbcpConnectionManager.java

/**
 * Returns an object pool configuration object populated with data
 * retrieved from the component's configuration.  Defaults correspond
 * to the <code>GenericObjectPool</code> default values.
 *   /*from  w w w.j  a v a2s  . c  o m*/
 * @return <code>GenericObjectPool.Config</code> instance containing
 * the pool's configuration parameters
 */
private GenericObjectPool.Config getPoolConfig() {
    GenericObjectPool.Config config = new GenericObjectPool.Config();
    if (m_pool != null) {
        config.maxActive = m_pool.getAttributeAsInteger("max-active", GenericObjectPool.DEFAULT_MAX_ACTIVE);
        config.maxIdle = m_pool.getAttributeAsInteger("max-idle", GenericObjectPool.DEFAULT_MAX_IDLE);
        config.maxWait = m_pool.getAttributeAsLong("max-wait", GenericObjectPool.DEFAULT_MAX_WAIT);
        config.minEvictableIdleTimeMillis = m_pool.getAttributeAsLong("min-evict-idle-time",
                GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
        config.minIdle = m_pool.getAttributeAsInteger("min-idle", GenericObjectPool.DEFAULT_MIN_IDLE);
        config.numTestsPerEvictionRun = m_pool.getAttributeAsInteger("num-evict-tests",
                GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN);
        config.testOnBorrow = m_pool.getAttributeAsBoolean("test-on-borrow",
                GenericObjectPool.DEFAULT_TEST_ON_BORROW);
        config.testOnReturn = m_pool.getAttributeAsBoolean("test-on-return",
                GenericObjectPool.DEFAULT_TEST_ON_RETURN);
        config.testWhileIdle = m_pool.getAttributeAsBoolean("test-while-idle",
                GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);
        config.timeBetweenEvictionRunsMillis = m_pool.getAttributeAsLong("time-between-evict-runs",
                GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS);
        config.whenExhaustedAction = GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION;
    }
    return config;
}

From source file:org.apache.cayenne.conf.CustomDBCPDataSourceBuilder.java

private KeyedObjectPoolFactory createPreparedStatementPool() {

    if (!config.getBoolean("poolPreparedStatements", false)) {
        return null;
    }//from   ww w  . j a  v a2s .  c  om

    // the GenericKeyedObjectPool.Config object isn't used because
    // although it has provision for the maxTotal parameter when
    // passed to the GenericKeyedObjectPoolFactory constructor
    // this parameter is not being properly set as a default for
    // creating prepared statement pools

    int maxActive = config.getInt(PS_MAX_ACTIVE, GenericObjectPool.DEFAULT_MAX_ACTIVE);
    byte whenExhaustedAction = config.getWhenExhaustedAction(PS_EXHAUSTED_ACTION,
            GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION);
    long maxWait = config.getLong(PS_MAX_WAIT, GenericObjectPool.DEFAULT_MAX_WAIT);
    int maxIdle = config.getInt(PS_MAX_IDLE, GenericObjectPool.DEFAULT_MAX_IDLE);
    int maxTotal = config.getInt(PS_MAX_TOTAL, 1);

    boolean testOnBorrow = config.getBoolean(PS_TEST_ON_BORROW, GenericObjectPool.DEFAULT_TEST_ON_BORROW);
    boolean testOnReturn = config.getBoolean(PS_TEST_ON_RETURN, GenericObjectPool.DEFAULT_TEST_ON_RETURN);

    long timeBetweenEvictionRunsMillis = config.getLong(PS_TIME_BETWEEN_EVICTIONS,
            GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS);
    int numTestsPerEvictionRun = config.getInt(PS_NUM_TEST_PER_EVICTION,
            GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN);

    long minEvictableIdleTimeMillis = config.getLong(PS_MIN_EVICTABLE_TIME,
            GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS);

    boolean testWhileIdle = config.getBoolean(PS_TEST_IDLE, GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);

    return new GenericKeyedObjectPoolFactory(null, maxActive, whenExhaustedAction, maxWait, maxIdle, maxTotal,
            testOnBorrow, testOnReturn, timeBetweenEvictionRunsMillis, numTestsPerEvictionRun,
            minEvictableIdleTimeMillis, testWhileIdle);
}

From source file:org.apache.cayenne.conf.CustomDBCPDataSourceBuilder.java

private GenericObjectPool.Config createConnectionPoolConfig() {
    GenericObjectPool.Config poolConfig = new GenericObjectPool.Config();

    poolConfig.maxIdle = config.getInt(MAX_IDLE, GenericObjectPool.DEFAULT_MAX_IDLE);
    poolConfig.minIdle = config.getInt(MIN_IDLE, GenericObjectPool.DEFAULT_MIN_IDLE);
    poolConfig.maxActive = config.getInt(MAX_ACTIVE, GenericObjectPool.DEFAULT_MAX_ACTIVE);
    poolConfig.maxWait = config.getLong(MAX_WAIT, GenericObjectPool.DEFAULT_MAX_WAIT);

    poolConfig.testOnBorrow = config.getBoolean(TEST_ON_BORROW, GenericObjectPool.DEFAULT_TEST_ON_BORROW);
    poolConfig.testOnReturn = config.getBoolean(TEST_ON_RETURN, GenericObjectPool.DEFAULT_TEST_ON_RETURN);
    poolConfig.testWhileIdle = config.getBoolean(TEST_IDLE, GenericObjectPool.DEFAULT_TEST_WHILE_IDLE);

    poolConfig.timeBetweenEvictionRunsMillis = config.getLong(TIME_BETWEEN_EVICTIONS,
            GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS);
    poolConfig.numTestsPerEvictionRun = config.getInt(NUM_TEST_PER_EVICTION,
            GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN);
    poolConfig.minEvictableIdleTimeMillis = config.getLong(MIN_EVICTABLE_TIME,
            GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS);

    poolConfig.whenExhaustedAction = config.getWhenExhaustedAction(EXHAUSTED_ACTION,
            GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION);

    return poolConfig;
}

From source file:org.apache.synapse.commons.datasource.factory.DataSourceInformationFactory.java

/**
 * Factory method to create a DataSourceInformation instance based on given properties
 *
 * @param dsName     DataSource Name/*from www .  java  2  s.  c om*/
 * @param properties Properties to create and configure DataSource
 * @return DataSourceInformation instance
 */
public static DataSourceInformation createDataSourceInformation(String dsName, Properties properties) {

    if (dsName == null || "".equals(dsName)) {
        if (log.isDebugEnabled()) {
            log.debug("DataSource name is either empty or null, ignoring..");
        }
        return null;
    }

    StringBuffer buffer = new StringBuffer();
    buffer.append(DataSourceConstants.PROP_SYNAPSE_PREFIX_DS);
    buffer.append(DataSourceConstants.DOT_STRING);
    buffer.append(dsName);
    buffer.append(DataSourceConstants.DOT_STRING);

    // Prefix for getting particular data source's properties
    String prefix = buffer.toString();

    String driver = MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_DRIVER_CLS_NAME,
            null);
    if (driver == null) {
        handleException(prefix + DataSourceConstants.PROP_DRIVER_CLS_NAME + " cannot be found.");
    }

    String url = MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_URL, null);
    if (url == null) {
        handleException(prefix + DataSourceConstants.PROP_URL + " cannot be found.");
    }

    DataSourceInformation datasourceInformation = new DataSourceInformation();
    datasourceInformation.setAlias(dsName);

    datasourceInformation.setDriver(driver);
    datasourceInformation.setUrl(url);

    String dataSourceName = MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_DS_NAME,
            dsName, String.class);
    datasourceInformation.setDatasourceName(dataSourceName);

    String dsType = MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_TYPE,
            DataSourceConstants.PROP_BASIC_DATA_SOURCE, String.class);

    datasourceInformation.setType(dsType);

    String repositoryType = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_REGISTRY, DataSourceConstants.PROP_REGISTRY_MEMORY, String.class);

    datasourceInformation.setRepositoryType(repositoryType);

    Integer maxActive = MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_MAX_ACTIVE,
            GenericObjectPool.DEFAULT_MAX_ACTIVE, Integer.class);
    datasourceInformation.setMaxActive(maxActive);

    Integer maxIdle = MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_MAX_IDLE,
            GenericObjectPool.DEFAULT_MAX_IDLE, Integer.class);
    datasourceInformation.setMaxIdle(maxIdle);

    Long maxWait = MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_MAX_WAIT,
            GenericObjectPool.DEFAULT_MAX_WAIT, Long.class);

    datasourceInformation.setMaxWait(maxWait);

    // Construct DriverAdapterCPDS reference
    String suffix = DataSourceConstants.PROP_CPDS_ADAPTER + DataSourceConstants.DOT_STRING
            + DataSourceConstants.PROP_CLASS_NAME;
    String className = MiscellaneousUtil.getProperty(properties, prefix + suffix,
            DataSourceConstants.PROP_CPDS_ADAPTER_DRIVER);
    datasourceInformation.addParameter(suffix, className);
    suffix = DataSourceConstants.PROP_CPDS_ADAPTER + DataSourceConstants.DOT_STRING
            + DataSourceConstants.PROP_FACTORY;
    String factory = MiscellaneousUtil.getProperty(properties, prefix + suffix,
            DataSourceConstants.PROP_CPDS_ADAPTER_DRIVER);
    datasourceInformation.addParameter(suffix, factory);
    suffix = DataSourceConstants.PROP_CPDS_ADAPTER + DataSourceConstants.DOT_STRING
            + DataSourceConstants.PROP_NAME;
    String name = MiscellaneousUtil.getProperty(properties, prefix + suffix, "cpds");
    datasourceInformation.addParameter(suffix, name);

    boolean defaultAutoCommit = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_DEFAULT_AUTO_COMMIT, true, Boolean.class);

    boolean defaultReadOnly = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_DEFAULT_READ_ONLY, false, Boolean.class);

    boolean testOnBorrow = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_TEST_ON_BORROW, true, Boolean.class);

    boolean testOnReturn = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_TEST_ON_RETURN, false, Boolean.class);

    long timeBetweenEvictionRunsMillis = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_TIME_BETWEEN_EVICTION_RUNS_MILLIS,
            GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS, Long.class);

    int numTestsPerEvictionRun = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_NUM_TESTS_PER_EVICTION_RUN,
            GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN, Integer.class);

    long minEvictableIdleTimeMillis = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_MIN_EVICTABLE_IDLE_TIME_MILLIS,
            GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS, Long.class);

    boolean testWhileIdle = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_TEST_WHILE_IDLE, false, Boolean.class);

    String validationQuery = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_VALIDATION_QUERY, null);

    int minIdle = MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_MIN_IDLE,
            GenericObjectPool.DEFAULT_MIN_IDLE, Integer.class);

    int initialSize = MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_INITIAL_SIZE,
            0, Integer.class);

    int defaultTransactionIsolation = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_DEFAULT_TRANSACTION_ISOLATION, -1, Integer.class);

    String defaultCatalog = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_DEFAULT_CATALOG, null);

    boolean accessToUnderlyingConnectionAllowed = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED, false, Boolean.class);

    boolean removeAbandoned = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_REMOVE_ABANDONED, false, Boolean.class);

    int removeAbandonedTimeout = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_REMOVE_ABANDONED_TIMEOUT, 300, Integer.class);

    boolean logAbandoned = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_LOG_ABANDONED, false, Boolean.class);

    boolean poolPreparedStatements = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_POOL_PREPARED_STATEMENTS, false, Boolean.class);

    int maxOpenPreparedStatements = MiscellaneousUtil.getProperty(properties,
            prefix + DataSourceConstants.PROP_MAX_OPEN_PREPARED_STATEMENTS,
            GenericKeyedObjectPool.DEFAULT_MAX_TOTAL, Integer.class);

    datasourceInformation.setDefaultAutoCommit(defaultAutoCommit);
    datasourceInformation.setDefaultReadOnly(defaultReadOnly);
    datasourceInformation.setTestOnBorrow(testOnBorrow);
    datasourceInformation.setTestOnReturn(testOnReturn);
    datasourceInformation.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
    datasourceInformation.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
    datasourceInformation.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
    datasourceInformation.setTestWhileIdle(testWhileIdle);
    datasourceInformation.setMinIdle(minIdle);
    datasourceInformation.setDefaultTransactionIsolation(defaultTransactionIsolation);
    datasourceInformation.setAccessToUnderlyingConnectionAllowed(accessToUnderlyingConnectionAllowed);
    datasourceInformation.setRemoveAbandoned(removeAbandoned);
    datasourceInformation.setRemoveAbandonedTimeout(removeAbandonedTimeout);
    datasourceInformation.setLogAbandoned(logAbandoned);
    datasourceInformation.setPoolPreparedStatements(poolPreparedStatements);
    datasourceInformation.setMaxOpenPreparedStatements(maxOpenPreparedStatements);
    datasourceInformation.setInitialSize(initialSize);

    if (validationQuery != null && !"".equals(validationQuery)) {
        datasourceInformation.setValidationQuery(validationQuery);
    }

    if (defaultCatalog != null && !"".equals(defaultCatalog)) {
        datasourceInformation.setDefaultCatalog(defaultCatalog);
    }

    datasourceInformation.addProperty(prefix + DataSourceConstants.PROP_IC_FACTORY,
            MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_IC_FACTORY, null));
    //Provider URL
    datasourceInformation.addProperty(prefix + DataSourceConstants.PROP_PROVIDER_URL,
            MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_PROVIDER_URL, null));

    datasourceInformation.addProperty(prefix + DataSourceConstants.PROP_PROVIDER_PORT,
            MiscellaneousUtil.getProperty(properties, prefix + DataSourceConstants.PROP_PROVIDER_PORT, null));

    String passwordPrompt = MiscellaneousUtil.getProperty(properties,
            prefix + SecurityConstants.PROP_PASSWORD_PROMPT, "Password for datasource " + dsName, String.class);

    SecretInformation secretInformation = SecretInformationFactory.createSecretInformation(properties, prefix,
            passwordPrompt);
    secretInformation.setToken(dsName + "." + SecurityConstants.PROP_PASSWORD);
    datasourceInformation.setSecretInformation(secretInformation);

    return datasourceInformation;
}

From source file:org.apache.synapse.util.DataSourceRegistrar.java

/**
 * Helper method to register a single data source .The given data source name is used ,
 * if there is no property with name dsName ,when,data source is binding to the initial context,
 *
 * @param dsName         The name of the data source
 * @param dsProperties   The property bag
 * @param initialContext The initial context instance
 * @param jndiEnv        The JNDI environment properties
 */// ww  w.j  a  v  a  2s .com
private static void registerDataSource(String dsName, Properties dsProperties, InitialContext initialContext,
        Properties jndiEnv) {

    if (dsName == null || "".equals(dsName)) {
        if (log.isDebugEnabled()) {
            log.debug("DataSource name is either empty or null, ignoring..");
        }
        return;
    }

    StringBuffer buffer = new StringBuffer();
    buffer.append(SynapseConstants.SYNAPSE_DATASOURCES);
    buffer.append(DOT_STRING);
    buffer.append(dsName);
    buffer.append(DOT_STRING);

    // Prefix for getting particular data source's properties
    String prefix = buffer.toString();

    String driver = getProperty(dsProperties, prefix + PROP_DRIVER_CLS_NAME, null);
    if (driver == null) {
        handleException(prefix + PROP_DRIVER_CLS_NAME + " cannot be found.");
    }

    String url = getProperty(dsProperties, prefix + PROP_URL, null);
    if (url == null) {
        handleException(prefix + PROP_URL + " cannot be found.");
    }

    // get other required properties
    String user = getProperty(dsProperties, prefix + PROP_USER_NAME, "synapse");
    String password = getProperty(dsProperties, prefix + PROP_PASSWORD, "synapse");
    String dataSourceName = getProperty(dsProperties, prefix + PROP_DSNAME, dsName);

    //populates context tree
    populateContextTree(initialContext, dataSourceName);

    String dsType = getProperty(dsProperties, prefix + "type", "BasicDataSource");

    String maxActive = getProperty(dsProperties, prefix + PROP_MAXACTIVE,
            String.valueOf(GenericObjectPool.DEFAULT_MAX_ACTIVE));
    String maxIdle = getProperty(dsProperties, prefix + PROP_MAXIDLE,
            String.valueOf(GenericObjectPool.DEFAULT_MAX_IDLE));
    String maxWait = getProperty(dsProperties, prefix + PROP_MAXWAIT,
            String.valueOf(GenericObjectPool.DEFAULT_MAX_WAIT));

    if ("BasicDataSource".equals(dsType)) {

        Reference ref = new Reference("javax.sql.DataSource", "org.apache.commons.dbcp.BasicDataSourceFactory",
                null);

        ref.add(new StringRefAddr(PROP_DRIVER_CLS_NAME, driver));
        ref.add(new StringRefAddr(PROP_URL, url));
        ref.add(new StringRefAddr(PROP_USER_NAME, user));
        ref.add(new StringRefAddr(PROP_PASSWORD, password));
        ref.add(new StringRefAddr(PROP_MAXACTIVE, maxActive));
        ref.add(new StringRefAddr(PROP_MAXIDLE, maxIdle));
        ref.add(new StringRefAddr(PROP_MAXWAIT, maxWait));

        //set BasicDataSource specific parameters
        setBasicDataSourceParameters(ref, dsProperties, prefix);
        //set default properties for reference
        setCommonParameters(ref, dsProperties, prefix);

        try {
            initialContext.rebind(dataSourceName, ref);
        } catch (NamingException e) {
            String msg = " Error binding name ' " + dataSourceName + " ' to "
                    + "the DataSource(BasicDataSource) reference";
            handleException(msg, e);
        }

    } else if ("PerUserPoolDataSource".equals(dsType)) {

        // Construct DriverAdapterCPDS reference
        String className = getProperty(dsProperties, prefix + PROP_CPDSADAPTER + DOT_STRING + "className",
                "org.apache.commons.dbcp.cpdsadapter.DriverAdapterCPDS");
        String factory = getProperty(dsProperties, prefix + PROP_CPDSADAPTER + DOT_STRING + "factory",
                "org.apache.commons.dbcp.cpdsadapter.DriverAdapterCPDS");
        String name = getProperty(dsProperties, prefix + PROP_CPDSADAPTER + DOT_STRING + "name", "cpds");

        Reference cpdsRef = new Reference(className, factory, null);

        cpdsRef.add(new StringRefAddr(PROP_DRIVER, driver));
        cpdsRef.add(new StringRefAddr(PROP_URL, url));
        cpdsRef.add(new StringRefAddr(PROP_USER, user));
        cpdsRef.add(new StringRefAddr(PROP_PASSWORD, password));

        try {
            initialContext.rebind(name, cpdsRef);
        } catch (NamingException e) {
            String msg = "Error binding name '" + name + "' to " + "the DriverAdapterCPDS reference";
            handleException(msg, e);
        }

        // Construct PerUserPoolDataSource reference
        Reference ref = new Reference("org.apache.commons.dbcp.datasources.PerUserPoolDataSource",
                "org.apache.commons.dbcp.datasources.PerUserPoolDataSourceFactory", null);

        ref.add(new BinaryRefAddr(PROP_JNDI_ENV, serialize(jndiEnv)));
        ref.add(new StringRefAddr(PROP_DATA_SOURCE_NAME, name));
        ref.add(new StringRefAddr(PROP_DEFAULTMAXACTIVE, maxActive));
        ref.add(new StringRefAddr(PROP_DEFAULTMAXIDLE, maxIdle));
        ref.add(new StringRefAddr(PROP_DEFAULTMAXWAIT, maxWait));

        //set default properties for reference
        setCommonParameters(ref, dsProperties, prefix);

        try {
            initialContext.rebind(dataSourceName, ref);
        } catch (NamingException e) {
            String msg = "Error binding name ' " + dataSourceName + " ' to "
                    + "the PerUserPoolDataSource reference";
            handleException(msg, e);
        }

    } else {
        handleException("Unsupported data source type : " + dsType);
    }
}

From source file:org.onexus.collection.store.h2sql.internal.H2CollectionStore.java

protected DataSource newDataSource() {

    Driver.load();//from ww w  . ja  v  a 2s . c  om

    // Initialize the DataSource with a connection pool
    ConnectionFactory connectionFactory = new H2ConnectionFactory();
    ObjectPool connectionPool = new GenericObjectPool(null, GenericObjectPool.DEFAULT_MAX_ACTIVE,
            GenericObjectPool.WHEN_EXHAUSTED_GROW, GenericObjectPool.DEFAULT_MAX_WAIT);
    @SuppressWarnings("unused")
    PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,
            connectionPool, null, null, false, true);
    return new PoolingDataSource(connectionPool);
}

From source file:org.onexus.website.api.widgets.tags.tagstore.TagStoreManager.java

public void init() {
    LOGGER.debug("Connecting to '{}' as '{}'.", database, username);

    Driver.load();//from w w w  .j a v a2s  . c  o m

    // Initialize the DataSource with a connection pool
    ConnectionFactory connectionFactory = new H2ConnectionFactory();
    ObjectPool connectionPool = new GenericObjectPool(null, GenericObjectPool.DEFAULT_MAX_ACTIVE,
            GenericObjectPool.WHEN_EXHAUSTED_GROW, GenericObjectPool.DEFAULT_MAX_WAIT);
    @SuppressWarnings("unused")
    PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,
            connectionPool, null, null, false, true);
    dataSource = new PoolingDataSource(connectionPool);

    this.tagStores = Collections.synchronizedMap(new HashMap<String, TagStore>());

}