Search in sources :

Example 1 with PoolableConnectionFactory

use of org.apache.commons.dbcp.PoolableConnectionFactory in project hive by apache.

the class TxnHandler method setupJdbcConnectionPool.

private static synchronized void setupJdbcConnectionPool(HiveConf conf) throws SQLException {
    if (connPool != null)
        return;
    String driverUrl = HiveConf.getVar(conf, HiveConf.ConfVars.METASTORECONNECTURLKEY);
    String user = getMetastoreJdbcUser(conf);
    String passwd = getMetastoreJdbcPasswd(conf);
    String connectionPooler = conf.getVar(HiveConf.ConfVars.METASTORE_CONNECTION_POOLING_TYPE).toLowerCase();
    if ("bonecp".equals(connectionPooler)) {
        BoneCPConfig config = new BoneCPConfig();
        config.setJdbcUrl(driverUrl);
        //if we are waiting for connection for 60s, something is really wrong
        //better raise an error than hang forever
        config.setConnectionTimeoutInMs(60000);
        config.setMaxConnectionsPerPartition(10);
        config.setPartitionCount(1);
        config.setUser(user);
        config.setPassword(passwd);
        connPool = new BoneCPDataSource(config);
        // Enable retries to work around BONECP bug.
        doRetryOnConnPool = true;
    } else if ("dbcp".equals(connectionPooler)) {
        ObjectPool objectPool = new GenericObjectPool();
        ConnectionFactory connFactory = new DriverManagerConnectionFactory(driverUrl, user, passwd);
        // This doesn't get used, but it's still necessary, see
        // http://svn.apache.org/viewvc/commons/proper/dbcp/branches/DBCP_1_4_x_BRANCH/doc/ManualPoolingDataSourceExample.java?view=markup
        PoolableConnectionFactory poolConnFactory = new PoolableConnectionFactory(connFactory, objectPool, null, null, false, true);
        connPool = new PoolingDataSource(objectPool);
    } else if ("hikaricp".equals(connectionPooler)) {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(driverUrl);
        config.setUsername(user);
        config.setPassword(passwd);
        connPool = new HikariDataSource(config);
    } else if ("none".equals(connectionPooler)) {
        LOG.info("Choosing not to pool JDBC connections");
        connPool = new NoPoolConnectionPool(conf);
    } else {
        throw new RuntimeException("Unknown JDBC connection pooling " + connectionPooler);
    }
}
Also used : PoolingDataSource(org.apache.commons.dbcp.PoolingDataSource) DriverManagerConnectionFactory(org.apache.commons.dbcp.DriverManagerConnectionFactory) HikariDataSource(com.zaxxer.hikari.HikariDataSource) BoneCPDataSource(com.jolbox.bonecp.BoneCPDataSource) GenericObjectPool(org.apache.commons.pool.impl.GenericObjectPool) HikariConfig(com.zaxxer.hikari.HikariConfig) PoolableConnectionFactory(org.apache.commons.dbcp.PoolableConnectionFactory) ConnectionFactory(org.apache.commons.dbcp.ConnectionFactory) DriverManagerConnectionFactory(org.apache.commons.dbcp.DriverManagerConnectionFactory) BoneCPConfig(com.jolbox.bonecp.BoneCPConfig) GenericObjectPool(org.apache.commons.pool.impl.GenericObjectPool) ObjectPool(org.apache.commons.pool.ObjectPool) PoolableConnectionFactory(org.apache.commons.dbcp.PoolableConnectionFactory)

Example 2 with PoolableConnectionFactory

use of org.apache.commons.dbcp.PoolableConnectionFactory in project hive by apache.

the class TxnHandler method setupJdbcConnectionPool.

private static synchronized DataSource setupJdbcConnectionPool(Configuration conf, int maxPoolSize, long getConnectionTimeoutMs) throws SQLException {
    String driverUrl = DataSourceProvider.getMetastoreJdbcDriverUrl(conf);
    String user = DataSourceProvider.getMetastoreJdbcUser(conf);
    String passwd = DataSourceProvider.getMetastoreJdbcPasswd(conf);
    String connectionPooler = MetastoreConf.getVar(conf, ConfVars.CONNECTION_POOLING_TYPE).toLowerCase();
    if ("bonecp".equals(connectionPooler)) {
        // Enable retries to work around BONECP bug.
        doRetryOnConnPool = true;
        return new BoneCPDataSourceProvider().create(conf);
    } else if ("dbcp".equals(connectionPooler)) {
        GenericObjectPool objectPool = new GenericObjectPool();
        // https://commons.apache.org/proper/commons-pool/api-1.6/org/apache/commons/pool/impl/GenericObjectPool.html#setMaxActive(int)
        objectPool.setMaxActive(maxPoolSize);
        objectPool.setMaxWait(getConnectionTimeoutMs);
        ConnectionFactory connFactory = new DriverManagerConnectionFactory(driverUrl, user, passwd);
        // This doesn't get used, but it's still necessary, see
        // http://svn.apache.org/viewvc/commons/proper/dbcp/branches/DBCP_1_4_x_BRANCH/doc/ManualPoolingDataSourceExample.java?view=markup
        PoolableConnectionFactory poolConnFactory = new PoolableConnectionFactory(connFactory, objectPool, null, null, false, true);
        return new PoolingDataSource(objectPool);
    } else if ("hikaricp".equals(connectionPooler)) {
        return new HikariCPDataSourceProvider().create(conf);
    } else if ("none".equals(connectionPooler)) {
        LOG.info("Choosing not to pool JDBC connections");
        return new NoPoolConnectionPool(conf);
    } else {
        throw new RuntimeException("Unknown JDBC connection pooling " + connectionPooler);
    }
}
Also used : PoolableConnectionFactory(org.apache.commons.dbcp.PoolableConnectionFactory) ConnectionFactory(org.apache.commons.dbcp.ConnectionFactory) DriverManagerConnectionFactory(org.apache.commons.dbcp.DriverManagerConnectionFactory) PoolingDataSource(org.apache.commons.dbcp.PoolingDataSource) DriverManagerConnectionFactory(org.apache.commons.dbcp.DriverManagerConnectionFactory) HikariCPDataSourceProvider(org.apache.hadoop.hive.metastore.datasource.HikariCPDataSourceProvider) BoneCPDataSourceProvider(org.apache.hadoop.hive.metastore.datasource.BoneCPDataSourceProvider) GenericObjectPool(org.apache.commons.pool.impl.GenericObjectPool) PoolableConnectionFactory(org.apache.commons.dbcp.PoolableConnectionFactory)

Example 3 with PoolableConnectionFactory

use of org.apache.commons.dbcp.PoolableConnectionFactory in project symmetric-ds by JumpMind.

the class ResettableBasicDataSource method createPoolableConnectionFactory.

@Override
protected void createPoolableConnectionFactory(ConnectionFactory driverConnectionFactory, KeyedObjectPoolFactory statementPoolFactory, AbandonedConfig configuration) throws SQLException {
    PoolableConnectionFactory connectionFactory = null;
    try {
        connectionFactory = new PoolableConnectionFactory(driverConnectionFactory, connectionPool, statementPoolFactory, validationQuery, validationQueryTimeout, connectionInitSqls, defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation, defaultCatalog, configuration);
        validateConnectionFactory(connectionFactory);
    } catch (Exception e) {
        try {
            connectionPool.close();
        } catch (Exception e1) {
        }
        throw new SQLNestedException("Cannot create PoolableConnectionFactory (" + e.getMessage() + ")", e);
    }
}
Also used : SQLNestedException(org.apache.commons.dbcp.SQLNestedException) PoolableConnectionFactory(org.apache.commons.dbcp.PoolableConnectionFactory) SQLException(java.sql.SQLException) SQLNestedException(org.apache.commons.dbcp.SQLNestedException)

Example 4 with PoolableConnectionFactory

use of org.apache.commons.dbcp.PoolableConnectionFactory in project zm-mailbox by Zimbra.

the class DbPool method getPool.

/**
 * Initializes the connection pool.
 */
private static synchronized PoolingDataSource getPool() {
    if (isShutdown)
        throw new RuntimeException("DbPool permanently shutdown");
    if (sPoolingDataSource != null)
        return sPoolingDataSource;
    PoolConfig pconfig = Db.getInstance().getPoolConfig();
    sConnectionPool = new GenericObjectPool(null, pconfig.mPoolSize, pconfig.whenExhaustedAction, -1, pconfig.mPoolSize);
    ConnectionFactory cfac = ZimbraConnectionFactory.getConnectionFactory(pconfig);
    boolean defAutoCommit = false, defReadOnly = false;
    new PoolableConnectionFactory(cfac, sConnectionPool, null, null, defReadOnly, defAutoCommit);
    try {
        // derby requires the .newInstance() call
        Class.forName(pconfig.mDriverClassName).newInstance();
        Class.forName("org.apache.commons.dbcp.PoolingDriver");
    } catch (Exception e) {
        ZimbraLog.system.fatal("can't instantiate DB driver/pool class", e);
        System.exit(1);
    }
    try {
        PoolingDataSource pds = new PoolingDataSource(sConnectionPool);
        pds.setAccessToUnderlyingConnectionAllowed(true);
        Db.getInstance().startup(pds, pconfig.mPoolSize);
        sPoolingDataSource = pds;
    } catch (SQLException e) {
        ZimbraLog.system.fatal("can't initialize connection pool", e);
        System.exit(1);
    }
    if (pconfig.mSupportsStatsCallback)
        ZimbraPerf.addStatsCallback(new DbStats());
    return sPoolingDataSource;
}
Also used : PoolableConnectionFactory(org.apache.commons.dbcp.PoolableConnectionFactory) ConnectionFactory(org.apache.commons.dbcp.ConnectionFactory) PoolingDataSource(org.apache.commons.dbcp.PoolingDataSource) SQLException(java.sql.SQLException) GenericObjectPool(org.apache.commons.pool.impl.GenericObjectPool) PoolableConnectionFactory(org.apache.commons.dbcp.PoolableConnectionFactory) ServiceException(com.zimbra.common.service.ServiceException) SQLException(java.sql.SQLException)

Example 5 with PoolableConnectionFactory

use of org.apache.commons.dbcp.PoolableConnectionFactory in project pentaho-platform by pentaho.

the class PooledDatasourceHelper method setupPooledDataSource.

public static PoolingDataSource setupPooledDataSource(IDatabaseConnection databaseConnection) throws DBDatasourceServiceException {
    PoolingDataSource poolingDataSource = null;
    String driverClass = null;
    String url = null;
    try {
        if (databaseConnection.getAccessType().equals(DatabaseAccessType.JNDI)) {
            throw new DBDatasourceServiceException(Messages.getInstance().getErrorString("PooledDatasourceHelper.ERROR_0008_UNABLE_TO_POOL_DATASOURCE_IT_IS_JNDI", databaseConnection.getName()));
        }
        ICacheManager cacheManager = PentahoSystem.getCacheManager(null);
        IDatabaseDialectService databaseDialectService = PentahoSystem.get(IDatabaseDialectService.class);
        if (databaseDialectService == null) {
            throw new DBDatasourceServiceException(Messages.getInstance().getErrorString("PooledDatasourceHelper.ERROR_0005_UNABLE_TO_POOL_DATASOURCE_NO_DIALECT_SERVICE", databaseConnection.getName()));
        }
        IDatabaseDialect dialect = databaseDialectService.getDialect(databaseConnection);
        if (dialect == null || dialect.getDatabaseType() == null) {
            throw new DBDatasourceServiceException(Messages.getInstance().getErrorString("PooledDatasourceHelper.ERROR_0004_UNABLE_TO_POOL_DATASOURCE_NO_DIALECT", databaseConnection.getName()));
        }
        if (databaseConnection.getDatabaseType().getShortName().equals("GENERIC")) {
            // $NON-NLS-1$
            driverClass = databaseConnection.getAttributes().get(GenericDatabaseDialect.ATTRIBUTE_CUSTOM_DRIVER_CLASS);
            if (StringUtils.isEmpty(driverClass)) {
                throw new DBDatasourceServiceException(Messages.getInstance().getErrorString("PooledDatasourceHelper.ERROR_0006_UNABLE_TO_POOL_DATASOURCE_NO_CLASSNAME", databaseConnection.getName()));
            }
        } else {
            driverClass = dialect.getNativeDriver();
            if (StringUtils.isEmpty(driverClass)) {
                throw new DBDatasourceServiceException(Messages.getInstance().getErrorString("PooledDatasourceHelper.ERROR_0007_UNABLE_TO_POOL_DATASOURCE_NO_DRIVER", databaseConnection.getName()));
            }
        }
        try {
            url = dialect.getURLWithExtraOptions(databaseConnection);
        } catch (DatabaseDialectException e) {
            url = null;
        }
        // Read default connection pooling parameter
        // $NON-NLS-1$
        String maxdleConn = PentahoSystem.getSystemSetting("dbcp-defaults/max-idle-conn", null);
        // $NON-NLS-1$
        String minIdleConn = PentahoSystem.getSystemSetting("dbcp-defaults/min-idle-conn", null);
        // $NON-NLS-1$
        String maxActConn = PentahoSystem.getSystemSetting("dbcp-defaults/max-act-conn", null);
        String validQuery = null;
        // $NON-NLS-1$
        String whenExhaustedAction = PentahoSystem.getSystemSetting("dbcp-defaults/when-exhausted-action", null);
        // $NON-NLS-1$
        String wait = PentahoSystem.getSystemSetting("dbcp-defaults/wait", null);
        // $NON-NLS-1$
        String testWhileIdleValue = PentahoSystem.getSystemSetting("dbcp-defaults/test-while-idle", null);
        // $NON-NLS-1$
        String testOnBorrowValue = PentahoSystem.getSystemSetting("dbcp-defaults/test-on-borrow", null);
        // $NON-NLS-1$
        String testOnReturnValue = PentahoSystem.getSystemSetting("dbcp-defaults/test-on-return", null);
        // property initialization
        boolean testWhileIdle = !StringUtil.isEmpty(testWhileIdleValue) ? Boolean.parseBoolean(testWhileIdleValue) : false;
        boolean testOnBorrow = !StringUtil.isEmpty(testOnBorrowValue) ? Boolean.parseBoolean(testOnBorrowValue) : false;
        boolean testOnReturn = !StringUtil.isEmpty(testOnReturnValue) ? Boolean.parseBoolean(testOnReturnValue) : false;
        int maxActiveConnection = !StringUtil.isEmpty(maxActConn) ? Integer.parseInt(maxActConn) : -1;
        long waitTime = !StringUtil.isEmpty(wait) ? Integer.parseInt(wait) : -1;
        byte whenExhaustedActionType = !StringUtil.isEmpty(whenExhaustedAction) ? Byte.parseByte(whenExhaustedAction) : GenericObjectPool.WHEN_EXHAUSTED_BLOCK;
        int minIdleConnection = !StringUtil.isEmpty(minIdleConn) ? Integer.parseInt(minIdleConn) : -1;
        int maxIdleConnection = !StringUtil.isEmpty(maxdleConn) ? Integer.parseInt(maxdleConn) : -1;
        // setting properties according to user specifications
        Map<String, String> attributes = databaseConnection.getConnectionPoolingProperties();
        if (attributes.containsKey(IDBDatasourceService.MAX_ACTIVE_KEY) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.MAX_ACTIVE_KEY))) {
            maxActiveConnection = Integer.parseInt(attributes.get(IDBDatasourceService.MAX_ACTIVE_KEY));
        }
        if (attributes.containsKey(IDBDatasourceService.MAX_WAIT_KEY) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.MAX_WAIT_KEY))) {
            waitTime = Integer.parseInt(attributes.get(IDBDatasourceService.MAX_WAIT_KEY));
        }
        if (attributes.containsKey(IDBDatasourceService.MIN_IDLE_KEY) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.MIN_IDLE_KEY))) {
            minIdleConnection = Integer.parseInt(attributes.get(IDBDatasourceService.MIN_IDLE_KEY));
        }
        if (attributes.containsKey(IDBDatasourceService.MAX_IDLE_KEY) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.MAX_IDLE_KEY))) {
            maxIdleConnection = Integer.parseInt(attributes.get(IDBDatasourceService.MAX_IDLE_KEY));
        }
        if (attributes.containsKey(IDBDatasourceService.QUERY_KEY)) {
            validQuery = attributes.get(IDBDatasourceService.QUERY_KEY);
        }
        if (attributes.containsKey(IDBDatasourceService.TEST_ON_BORROW)) {
            testOnBorrow = Boolean.parseBoolean(attributes.get(IDBDatasourceService.TEST_ON_BORROW));
        }
        if (attributes.containsKey(IDBDatasourceService.TEST_ON_RETURN)) {
            testOnReturn = Boolean.parseBoolean(attributes.get(IDBDatasourceService.TEST_ON_RETURN));
        }
        if (attributes.containsKey(IDBDatasourceService.TEST_WHILE_IDLE)) {
            testWhileIdle = Boolean.parseBoolean(attributes.get(IDBDatasourceService.TEST_WHILE_IDLE));
        }
        poolingDataSource = new PoolingDataSource();
        if (dialect instanceof IDriverLocator) {
            if (!((IDriverLocator) dialect).initialize(driverClass)) {
                throw new DriverNotInitializedException(Messages.getInstance().getErrorString("PooledDatasourceHelper.ERROR_0009_UNABLE_TO_POOL_DATASOURCE_CANT_INITIALIZE", databaseConnection.getName(), driverClass));
            }
        } else {
            Class.forName(driverClass);
        }
        // As the name says, this is a generic pool; it returns basic Object-class objects.
        GenericObjectPool pool = new GenericObjectPool(null);
        // if removedAbandoned = true, then an AbandonedObjectPool object will take GenericObjectPool's place
        if (attributes.containsKey(IDBDatasourceService.REMOVE_ABANDONED) && true == Boolean.parseBoolean(attributes.get(IDBDatasourceService.REMOVE_ABANDONED))) {
            AbandonedConfig config = new AbandonedConfig();
            config.setRemoveAbandoned(Boolean.parseBoolean(attributes.get(IDBDatasourceService.REMOVE_ABANDONED)));
            if (attributes.containsKey(IDBDatasourceService.LOG_ABANDONED)) {
                config.setLogAbandoned(Boolean.parseBoolean(attributes.get(IDBDatasourceService.LOG_ABANDONED)));
            }
            if (attributes.containsKey(IDBDatasourceService.REMOVE_ABANDONED_TIMEOUT) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.REMOVE_ABANDONED_TIMEOUT))) {
                config.setRemoveAbandonedTimeout(Integer.parseInt(attributes.get(IDBDatasourceService.REMOVE_ABANDONED_TIMEOUT)));
            }
            pool = new AbandonedObjectPool(null, config);
        }
        pool.setWhenExhaustedAction(whenExhaustedActionType);
        // Tuning the connection pool
        pool.setMaxActive(maxActiveConnection);
        pool.setMaxIdle(maxIdleConnection);
        pool.setMaxWait(waitTime);
        pool.setMinIdle(minIdleConnection);
        pool.setTestWhileIdle(testWhileIdle);
        pool.setTestOnReturn(testOnReturn);
        pool.setTestOnBorrow(testOnBorrow);
        pool.setTestWhileIdle(testWhileIdle);
        if (attributes.containsKey(IDBDatasourceService.TIME_BETWEEN_EVICTION_RUNS_MILLIS) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.TIME_BETWEEN_EVICTION_RUNS_MILLIS))) {
            pool.setTimeBetweenEvictionRunsMillis(Long.parseLong(attributes.get(IDBDatasourceService.TIME_BETWEEN_EVICTION_RUNS_MILLIS)));
        }
        /*
       * ConnectionFactory creates connections on behalf of the pool. Here, we use the DriverManagerConnectionFactory
       * because that essentially uses DriverManager as the source of connections.
       */
        ConnectionFactory factory = null;
        if (url.startsWith("jdbc:mysql:") || (url.startsWith("jdbc:mariadb:"))) {
            Properties props = new Properties();
            props.put("user", databaseConnection.getUsername());
            props.put("password", databaseConnection.getPassword());
            props.put("socketTimeout", "0");
            props.put("connectTimeout", "5000");
            factory = new DriverManagerConnectionFactory(url, props);
        } else {
            factory = new DriverManagerConnectionFactory(url, databaseConnection.getUsername(), databaseConnection.getPassword());
        }
        boolean defaultReadOnly = attributes.containsKey(IDBDatasourceService.DEFAULT_READ_ONLY) ? Boolean.parseBoolean(attributes.get(IDBDatasourceService.TEST_WHILE_IDLE)) : // default to false
        false;
        boolean defaultAutoCommit = attributes.containsKey(IDBDatasourceService.DEFAULT_AUTO_COMMIT) ? Boolean.parseBoolean(attributes.get(IDBDatasourceService.DEFAULT_AUTO_COMMIT)) : // default to true
        true;
        KeyedObjectPoolFactory kopf = null;
        if (attributes.containsKey(IDBDatasourceService.POOL_PREPARED_STATEMENTS) && true == Boolean.parseBoolean(attributes.get(IDBDatasourceService.POOL_PREPARED_STATEMENTS))) {
            // unlimited
            int maxOpenPreparedStatements = -1;
            if (attributes.containsKey(IDBDatasourceService.MAX_OPEN_PREPARED_STATEMENTS) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.MAX_OPEN_PREPARED_STATEMENTS))) {
                maxOpenPreparedStatements = Integer.parseInt(attributes.get(IDBDatasourceService.MAX_OPEN_PREPARED_STATEMENTS));
            }
            kopf = new GenericKeyedObjectPoolFactory(null, pool.getMaxActive(), pool.getWhenExhaustedAction(), pool.getMaxWait(), pool.getMaxIdle(), maxOpenPreparedStatements);
        }
        /*
       * Puts pool-specific wrappers on factory connections. For clarification: "[PoolableConnection]Factory," not
       * "Poolable[ConnectionFactory]."
       */
        PoolableConnectionFactory pcf = new PoolableConnectionFactory(// ConnectionFactory
        factory, // ObjectPool
        pool, // KeyedObjectPoolFactory
        kopf, // String (validation query)
        validQuery, // boolean (default to read-only?)
        defaultReadOnly, // boolean (default to auto-commit statements?)
        defaultAutoCommit);
        if (attributes.containsKey(IDBDatasourceService.DEFAULT_TRANSACTION_ISOLATION) && !IDBDatasourceService.TRANSACTION_ISOLATION_NONE_VALUE.equalsIgnoreCase(attributes.get(IDBDatasourceService.DEFAULT_TRANSACTION_ISOLATION))) {
            Isolation isolationLevel = Isolation.valueOf(attributes.get(IDBDatasourceService.DEFAULT_TRANSACTION_ISOLATION));
            if (isolationLevel != null) {
                pcf.setDefaultTransactionIsolation(isolationLevel.value());
            }
        }
        if (attributes.containsKey(IDBDatasourceService.DEFAULT_CATALOG)) {
            pcf.setDefaultCatalog(attributes.get(IDBDatasourceService.DEFAULT_CATALOG));
        }
        /*
       * initialize the pool to X connections
       */
        Logger.debug(PooledDatasourceHelper.class, "Pool defaults to " + maxActiveConnection + " max active/" + maxIdleConnection + "max idle" + "with " + waitTime + // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
        "wait time" + // $NON-NLS-1$
        " idle connections.");
        String prePopulatePoolStr = PentahoSystem.getSystemSetting("dbcp-defaults/pre-populate-pool", null);
        if (Boolean.parseBoolean(prePopulatePoolStr)) {
            for (int i = 0; i < maxIdleConnection; ++i) {
                pool.addObject();
            }
            if (Logger.getLogLevel() <= ILogger.DEBUG) {
                Logger.debug(PooledDatasourceHelper.class, "Pool has been pre-populated with " + maxIdleConnection + " connections");
            }
        }
        Logger.debug(PooledDatasourceHelper.class, "Pool now has " + pool.getNumActive() + " active/" + pool.getNumIdle() + // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
        " idle connections.");
        /*
       * All of this is wrapped in a DataSource, which client code should already know how to handle (since it's the
       * same class of object they'd fetch via the container's JNDI tree
       */
        poolingDataSource.setPool(pool);
        if (attributes.containsKey(IDBDatasourceService.ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED)) {
            poolingDataSource.setAccessToUnderlyingConnectionAllowed(Boolean.parseBoolean(attributes.get(IDBDatasourceService.ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED)));
        }
        // store the pool, so we can get to it later
        cacheManager.putInRegionCache(IDBDatasourceService.JDBC_POOL, databaseConnection.getName(), pool);
        return (poolingDataSource);
    } catch (Exception e) {
        throw new DBDatasourceServiceException(e);
    }
}
Also used : AbandonedConfig(org.apache.commons.dbcp.AbandonedConfig) DriverManagerConnectionFactory(org.apache.commons.dbcp.DriverManagerConnectionFactory) IDatabaseDialect(org.pentaho.database.IDatabaseDialect) IDatabaseDialectService(org.pentaho.database.service.IDatabaseDialectService) Properties(java.util.Properties) GenericKeyedObjectPoolFactory(org.apache.commons.pool.impl.GenericKeyedObjectPoolFactory) KeyedObjectPoolFactory(org.apache.commons.pool.KeyedObjectPoolFactory) PoolableConnectionFactory(org.apache.commons.dbcp.PoolableConnectionFactory) ConnectionFactory(org.apache.commons.dbcp.ConnectionFactory) DriverManagerConnectionFactory(org.apache.commons.dbcp.DriverManagerConnectionFactory) PoolableConnectionFactory(org.apache.commons.dbcp.PoolableConnectionFactory) PoolingDataSource(org.apache.commons.dbcp.PoolingDataSource) AbandonedObjectPool(org.apache.commons.dbcp.AbandonedObjectPool) GenericObjectPool(org.apache.commons.pool.impl.GenericObjectPool) NamingException(javax.naming.NamingException) DBDatasourceServiceException(org.pentaho.platform.api.data.DBDatasourceServiceException) DatabaseDialectException(org.pentaho.database.DatabaseDialectException) GenericKeyedObjectPoolFactory(org.apache.commons.pool.impl.GenericKeyedObjectPoolFactory) DBDatasourceServiceException(org.pentaho.platform.api.data.DBDatasourceServiceException) DatabaseDialectException(org.pentaho.database.DatabaseDialectException) Isolation(org.springframework.transaction.annotation.Isolation) ICacheManager(org.pentaho.platform.api.engine.ICacheManager) IDriverLocator(org.pentaho.database.IDriverLocator)

Aggregations

PoolableConnectionFactory (org.apache.commons.dbcp.PoolableConnectionFactory)7 ConnectionFactory (org.apache.commons.dbcp.ConnectionFactory)6 PoolingDataSource (org.apache.commons.dbcp.PoolingDataSource)6 GenericObjectPool (org.apache.commons.pool.impl.GenericObjectPool)6 DriverManagerConnectionFactory (org.apache.commons.dbcp.DriverManagerConnectionFactory)5 SQLException (java.sql.SQLException)4 Properties (java.util.Properties)2 KeyedObjectPoolFactory (org.apache.commons.pool.KeyedObjectPoolFactory)2 GenericKeyedObjectPoolFactory (org.apache.commons.pool.impl.GenericKeyedObjectPoolFactory)2 BoneCPConfig (com.jolbox.bonecp.BoneCPConfig)1 BoneCPDataSource (com.jolbox.bonecp.BoneCPDataSource)1 HikariConfig (com.zaxxer.hikari.HikariConfig)1 HikariDataSource (com.zaxxer.hikari.HikariDataSource)1 ServiceException (com.zimbra.common.service.ServiceException)1 IOException (java.io.IOException)1 NamingException (javax.naming.NamingException)1 AbandonedConfig (org.apache.commons.dbcp.AbandonedConfig)1 AbandonedObjectPool (org.apache.commons.dbcp.AbandonedObjectPool)1 SQLNestedException (org.apache.commons.dbcp.SQLNestedException)1 ObjectPool (org.apache.commons.pool.ObjectPool)1