| /* |
| * Copyright (c) 2021, 2022 Contributors to the Eclipse Foundation. |
| * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0, which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * This Source Code may also be made available under the following Secondary |
| * Licenses when the conditions for such availability set forth in the |
| * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, |
| * version 2 with the GNU Classpath Exception, which is available at |
| * https://www.gnu.org/software/classpath/license.html. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 |
| */ |
| |
| package com.sun.gjc.spi; |
| |
| import static com.sun.gjc.common.DataSourceSpec.CONNECTIONVALIDATIONREQUIRED; |
| import static com.sun.gjc.common.DataSourceSpec.GUARANTEEISOLATIONLEVEL; |
| import static com.sun.gjc.common.DataSourceSpec.TRANSACTIONISOLATION; |
| import static com.sun.gjc.common.DataSourceSpec.VALIDATIONCLASSNAME; |
| import static com.sun.gjc.common.DataSourceSpec.VALIDATIONMETHOD; |
| import static com.sun.gjc.util.SecurityUtils.getPasswordCredential; |
| import static com.sun.gjc.util.SecurityUtils.isPasswordCredentialEqual; |
| import static java.util.logging.Level.FINE; |
| import static java.util.logging.Level.INFO; |
| import static java.util.logging.Level.SEVERE; |
| |
| import java.io.Externalizable; |
| import java.io.IOException; |
| import java.io.ObjectInput; |
| import java.io.ObjectOutput; |
| import java.io.PrintWriter; |
| import java.io.Serializable; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.InvocationTargetException; |
| import java.sql.Connection; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Locale; |
| import java.util.NoSuchElementException; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| import java.util.Timer; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| import javax.security.auth.Subject; |
| import javax.sql.DataSource; |
| import javax.sql.PooledConnection; |
| |
| import org.glassfish.api.jdbc.ConnectionValidation; |
| import org.glassfish.api.jdbc.SQLTraceListener; |
| import org.glassfish.external.probe.provider.PluginPoint; |
| import org.glassfish.external.probe.provider.StatsProviderManager; |
| import org.glassfish.resourcebase.resources.api.PoolInfo; |
| |
| import com.sun.appserv.connectors.internal.spi.MCFLifecycleListener; |
| import com.sun.enterprise.util.i18n.StringManager; |
| import com.sun.gjc.common.DataSourceObjectBuilder; |
| import com.sun.gjc.common.DataSourceSpec; |
| import com.sun.gjc.monitoring.JdbcStatsProvider; |
| import com.sun.gjc.util.SQLTraceDelegator; |
| import com.sun.logging.LogDomains; |
| |
| import jakarta.resource.ResourceException; |
| import jakarta.resource.spi.ConfigProperty; |
| import jakarta.resource.spi.ConnectionManager; |
| import jakarta.resource.spi.ConnectionRequestInfo; |
| import jakarta.resource.spi.LazyEnlistableConnectionManager; |
| import jakarta.resource.spi.ManagedConnection; |
| import jakarta.resource.spi.ManagedConnectionFactory; |
| import jakarta.resource.spi.ResourceAdapter; |
| import jakarta.resource.spi.ResourceAdapterAssociation; |
| import jakarta.resource.spi.ResourceAllocationException; |
| import jakarta.resource.spi.ValidatingManagedConnectionFactory; |
| import jakarta.resource.spi.security.PasswordCredential; |
| |
| /** |
| * <code>ManagedConnectionFactory</code> implementation for Generic JDBC |
| * Connector. This class is extended by the DataSource specific |
| * <code>ManagedConnection</code> factories and the |
| * <code>ManagedConnectionFactory</code> for the <code>DriverManager</code>. |
| * |
| * @author Evani Sai Surya Kiran, Aditya Gore |
| * @version 1.0, 02/08/03 |
| */ |
| |
| public abstract class ManagedConnectionFactoryImpl |
| implements ManagedConnectionFactory, ValidatingManagedConnectionFactory, MCFLifecycleListener, |
| ResourceAdapterAssociation, Serializable, Externalizable { |
| |
| private static Logger _logger = LogDomains.getLogger(ManagedConnectionFactoryImpl.class, LogDomains.RSR_LOGGER); |
| protected static final StringManager localStrings = StringManager.getManager(DataSourceObjectBuilder.class); |
| |
| protected DataSourceSpec spec = new DataSourceSpec(); |
| protected transient DataSourceObjectBuilder dataSourceObjectBuilder; |
| protected PrintWriter logWriter; |
| protected transient ResourceAdapter resourceAdapter; |
| protected boolean statementWrapping; |
| protected SQLTraceDelegator sqlTraceDelegator; |
| protected LazyEnlistableConnectionManager connectionManager; |
| protected boolean isLazyConnectionManager; |
| |
| private JdbcObjectsFactory jdbcObjectsFactory = JdbcObjectsFactory.getInstance(); |
| private int statementCacheSize; |
| private String statementCacheType; |
| private long statementLeakTimeout; |
| private boolean statementLeakReclaim; |
| |
| // Jdbc Stats provider that is created |
| private JdbcStatsProvider jdbcStatsProvider; |
| |
| /** |
| * Creates a Connection Factory instance. The <code>ConnectionManager</code> |
| * implementation of the resource adapter is used here. |
| * |
| * @return Generic JDBC Connector implementation of |
| * <code>javax.sql.DataSource</code> |
| */ |
| @Override |
| public Object createConnectionFactory() { |
| logFine("In createConnectionFactory()"); |
| return jdbcObjectsFactory.getDataSourceInstance(this, null); |
| } |
| |
| /** |
| * Creates a Connection Factory instance. The <code>ConnectionManager</code> |
| * implementation of the application server is used here. |
| * |
| * @param connectionManager <code>ConnectionManager</code> passed by the application |
| * server |
| * @return Generic JDBC Connector implementation of |
| * <code>javax.sql.DataSource</code> |
| */ |
| @Override |
| public Object createConnectionFactory(ConnectionManager connectionManager) { |
| logFine("In createConnectionFactory(jakarta.resource.spi.ConnectionManager cxManager)"); |
| |
| DataSource connectionFactory = jdbcObjectsFactory.getDataSourceInstance(this, connectionManager); |
| |
| if (connectionManager instanceof LazyEnlistableConnectionManager) { |
| this.connectionManager = (LazyEnlistableConnectionManager) connectionManager; |
| isLazyConnectionManager = true; |
| } |
| |
| return connectionFactory; |
| } |
| |
| /** |
| * Creates a new physical connection to the underlying EIS resource manager. |
| * |
| * @param subject <code>Subject</code> instance passed by the application server |
| * @param cxRequestInfo <code>ConnectionRequestInfo</code> which may be created |
| * as a result of the invocation <code>getConnection(user, password)</code> on |
| * the <code>DataSource</code> object |
| * |
| * @return <code>ManagedConnection</code> object created |
| * @throws ResourceException if there is an error in instantiating the |
| * <code>DataSource</code> object used for the creation of the |
| * <code>ManagedConnection</code> object |
| * @throws SecurityException if there ino <code>PasswordCredential</code> object |
| * satisfying this request |
| * @throws ResourceException if there is an error in allocating the physical |
| * connection |
| */ |
| @Override |
| public abstract ManagedConnection createManagedConnection(Subject subject, ConnectionRequestInfo cxRequestInfo) throws ResourceException; |
| |
| /** |
| * Check if this <code>ManagedConnectionFactoryImpl</code> is equal to another |
| * <code>ManagedConnectionFactoryImpl</code>. |
| * |
| * @param other <code>ManagedConnectionFactoryImpl</code> object for checking |
| * equality with |
| * @return true if the property sets of both the |
| * <code>ManagedConnectionFactoryImpl</code> objects are the same false |
| * otherwise |
| */ |
| @Override |
| public abstract boolean equals(Object other); |
| |
| /** |
| * Get the log writer for this <code>ManagedConnectionFactoryImpl</code> |
| * instance. |
| * |
| * @return <code>PrintWriter</code> associated with this |
| * <code>ManagedConnectionFactoryImpl</code> instance |
| * @see <code>setLogWriter</code> |
| */ |
| @Override |
| public java.io.PrintWriter getLogWriter() { |
| return logWriter; |
| } |
| |
| /** |
| * Get the <code>ResourceAdapterImpl</code> for this |
| * <code>ManagedConnectionFactoryImpl</code> instance. |
| * |
| * @return <code>ResourceAdapterImpl</code> associated with this |
| * <code>ManagedConnectionFactoryImpl</code> instance |
| * @see <code>setResourceAdapter</code> |
| */ |
| @Override |
| public jakarta.resource.spi.ResourceAdapter getResourceAdapter() { |
| logFine("In getResourceAdapter"); |
| return resourceAdapter; |
| } |
| |
| /** |
| * Returns the hash code for this <code>ManagedConnectionFactoryImpl</code>. |
| * |
| * @return hash code for this <code>ManagedConnectionFactoryImpl</code> |
| */ |
| @Override |
| public int hashCode() { |
| logFine("In hashCode"); |
| return spec.hashCode(); |
| } |
| |
| /** |
| * Returns a matched <code>ManagedConnection</code> from the candidate set of |
| * <code>ManagedConnection</code> objects. |
| * |
| * @param connectionSet <code>Set</code> of <code>ManagedConnection</code> |
| * objects passed by the application server |
| * @param subject passed by the application server for retrieving information |
| * required for matching |
| * @param cxRequestInfo <code>ConnectionRequestInfo</code> passed by the |
| * application server for retrieving information required for matching |
| * @return <code>ManagedConnection</code> that is the best match satisfying this |
| * request |
| * @throws ResourceException if there is an error accessing the |
| * <code>Subject</code> parameter or the <code>Set</code> of |
| * <code>ManagedConnection</code> objects passed by the application server |
| */ |
| @Override |
| public ManagedConnection matchManagedConnections(Set connectionSet, Subject subject, ConnectionRequestInfo cxRequestInfo) throws ResourceException { |
| logFine("In matchManagedConnections"); |
| |
| if (connectionSet == null) { |
| return null; |
| } |
| |
| PasswordCredential passwordCredential = getPasswordCredential(this, subject, cxRequestInfo); |
| |
| Iterator<ManagedConnectionImpl> iter = connectionSet.iterator(); |
| ManagedConnectionImpl managedConnectionImpl = null; |
| |
| while (iter.hasNext()) { |
| try { |
| managedConnectionImpl = iter.next(); |
| } catch (NoSuchElementException nsee) { |
| _logger.log(SEVERE, "jdbc.exc_iter"); |
| throw new ResourceException(nsee.getMessage()); |
| } |
| if (passwordCredential == null && this.equals(managedConnectionImpl.getManagedConnectionFactory())) { |
| return managedConnectionImpl; |
| } |
| |
| if (isPasswordCredentialEqual(passwordCredential, managedConnectionImpl.getPasswordCredential())) { |
| return managedConnectionImpl; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * This method returns a set of invalid <code>ManagedConnection</code> objects |
| * chosen from a specified set of <code>ManagedConnection</code> objects. |
| * |
| * @param connectionSet a set of <code>ManagedConnection</code> objects that |
| * need to be validated. |
| * @return a set of invalid <code>ManagedConnection</code> objects. |
| * @throws ResourceException generic exception. |
| */ |
| @Override |
| public Set getInvalidConnections(Set connectionSet) throws ResourceException { |
| Iterator iter = connectionSet.iterator(); |
| Set<ManagedConnectionImpl> invalidConnections = new HashSet<ManagedConnectionImpl>(); |
| while (iter.hasNext()) { |
| ManagedConnectionImpl managedConnectionImpl = (ManagedConnectionImpl) iter.next(); |
| try { |
| isValid(managedConnectionImpl); |
| } catch (ResourceException re) { |
| invalidConnections.add(managedConnectionImpl); |
| managedConnectionImpl.connectionErrorOccurred(re, null); |
| _logger.log(FINE, "jdbc.invalid_connection", re); |
| } |
| } |
| |
| return invalidConnections; |
| } |
| |
| /** |
| * Checks if a <code>ManagedConnection</code> is to be validated or not and |
| * validates it or returns. |
| * |
| * @param managedConnectionImpl <code>ManagedConnection</code> to be validated |
| * @throws ResourceException if the connection is not valid or if validation |
| * method is not proper |
| */ |
| void isValid(ManagedConnectionImpl managedConnectionImpl) throws ResourceException { |
| if (managedConnectionImpl == null || managedConnectionImpl.isTransactionInProgress()) { |
| return; |
| } |
| |
| String conVal = spec.getDetail(CONNECTIONVALIDATIONREQUIRED); |
| |
| boolean connectionValidationRequired = (conVal == null) ? |
| false : |
| Boolean.valueOf(conVal.toLowerCase(Locale.getDefault())); |
| if (!connectionValidationRequired) { |
| return; |
| } |
| |
| String validationMethod = spec.getDetail(VALIDATIONMETHOD).toLowerCase(Locale.getDefault()); |
| |
| managedConnectionImpl.checkIfValid(); |
| |
| /** |
| * The above call checks if the actual physical connection is usable or not. |
| */ |
| Connection connection = managedConnectionImpl.getActualConnection(); |
| |
| if (validationMethod.equals("custom-validation")) { |
| isValidByCustomValidation(connection, spec.getDetail(VALIDATIONCLASSNAME)); |
| } else if (validationMethod.equals("auto-commit")) { |
| isValidByAutoCommit(connection); |
| } else if (validationMethod.equals("meta-data")) { |
| isValidByMetaData(connection); |
| } else if (validationMethod.equals("table")) { |
| isValidByTableQuery(connection, spec.getDetail(DataSourceSpec.VALIDATIONTABLENAME)); |
| } else { |
| throw new ResourceException("The validation method is not proper"); |
| } |
| } |
| |
| /** |
| * Checks if a <code>java.sql.Connection</code> is valid or not by doing a |
| * custom validation using the validation class name specified. |
| * |
| * @param connection <code>java.sql.Connection</code> to be validated |
| * @throws ResourceException if the connection is not valid |
| */ |
| protected void isValidByCustomValidation(Connection connection, String validationClassName) throws ResourceException { |
| boolean isValid = false; |
| if (connection == null) { |
| throw new ResourceException("The connection is not valid as " + "the connection is null"); |
| } |
| |
| try { |
| ConnectionValidation connectionValidation = (ConnectionValidation) |
| Thread.currentThread() |
| .getContextClassLoader() |
| .loadClass(validationClassName) |
| .getDeclaredConstructor() |
| .newInstance(); |
| |
| isValid = connectionValidation.isConnectionValid(connection); |
| } catch (Exception e) { |
| _logger.log(INFO, "jdbc.exc_custom_validation", validationClassName); |
| throw new ResourceException(e); |
| } |
| |
| if (!isValid) { |
| _logger.log(INFO, "jdbc.exc_custom_validation", validationClassName); |
| throw new ResourceException("Custom validation detected invalid connection"); |
| } |
| } |
| |
| /** |
| * Checks if a <code>java.sql.Connection</code> is valid or not by checking its |
| * auto commit property. |
| * |
| * @param connection <code>java.sql.Connection</code> to be validated |
| * @throws ResourceException if the connection is not valid |
| */ |
| protected void isValidByAutoCommit(Connection connection) throws ResourceException { |
| if (connection == null) { |
| throw new ResourceException("The connection is not valid as " + "the connection is null"); |
| } |
| |
| try { |
| // Notice that using something like |
| // dbCon.setAutoCommit(dbCon.getAutoCommit()) will cause problems with |
| // some drivers like sybase |
| // We do not validate connections that are already enlisted |
| // in a transaction |
| // We cycle autocommit to true and false to by-pass drivers that |
| // might cache the call to set autocomitt |
| // Also notice that some XA data sources will throw and exception if |
| // you try to call setAutoCommit, for them this method is not recommended |
| |
| boolean autoCommit = connection.getAutoCommit(); |
| if (autoCommit) { |
| connection.setAutoCommit(false); |
| } else { |
| connection.rollback(); // prevents uncompleted transaction exceptions |
| connection.setAutoCommit(true); |
| } |
| |
| connection.setAutoCommit(autoCommit); |
| |
| } catch (Exception sqle) { |
| _logger.log(INFO, "jdbc.exc_autocommit_validation"); |
| throw new ResourceException(sqle); |
| } |
| } |
| |
| /** |
| * Checks if a <code>java.sql.Connection</code> is valid or not by checking its |
| * meta data. |
| * |
| * @param connection <code>java.sql.Connection</code> to be validated |
| * @throws ResourceException if the connection is not valid |
| */ |
| protected void isValidByMetaData(Connection connection) throws ResourceException { |
| if (connection == null) { |
| throw new ResourceException("The connection is not valid as " + "the connection is null"); |
| } |
| |
| try { |
| connection.getMetaData(); |
| } catch (Exception sqle) { |
| _logger.log(INFO, "jdbc.exc_metadata_validation"); |
| throw new ResourceException(sqle); |
| } |
| } |
| |
| /** |
| * Checks if a <code>java.sql.Connection</code> is valid or not by querying a |
| * table. |
| * |
| * @param connection <code>java.sql.Connection</code> to be validated |
| * @param tableName table which should be queried |
| * @throws ResourceException if the connection is not valid |
| */ |
| protected void isValidByTableQuery(Connection connection, String tableName) throws ResourceException { |
| if (connection == null) { |
| throw new ResourceException("The connection is not valid as " + "the connection is null"); |
| } |
| |
| PreparedStatement preparedStatement = null; |
| ResultSet resultSet = null; |
| try { |
| preparedStatement = connection.prepareStatement("SELECT COUNT(*) FROM " + tableName); |
| resultSet = preparedStatement.executeQuery(); |
| } catch (Exception sqle) { |
| _logger.log(INFO, "jdbc.exc_table_validation", tableName); |
| throw new ResourceException(sqle); |
| } finally { |
| try { |
| if (resultSet != null) { |
| resultSet.close(); |
| } |
| } catch (Exception e1) { |
| } |
| |
| try { |
| if (preparedStatement != null) { |
| preparedStatement.close(); |
| } |
| } catch (Exception e2) { |
| } |
| } |
| } |
| |
| /** |
| * Sets the isolation level specified in the <code>ConnectionRequestInfo</code> |
| * for the <code>ManagedConnection</code> passed. |
| * |
| * @param managedConnectionImpl <code>ManagedConnection</code> |
| * @throws ResourceException if the isolation property is invalid or if the |
| * isolation cannot be set over the connection |
| */ |
| protected void setIsolation(ManagedConnectionImpl managedConnectionImpl) throws ResourceException { |
| Connection connection = managedConnectionImpl.getActualConnection(); |
| if (connection == null) { |
| return; |
| } |
| |
| String tranIsolation = spec.getDetail(TRANSACTIONISOLATION); |
| if (tranIsolation != null && !tranIsolation.equals("")) { |
| int tranIsolationInt = getTransactionIsolationInt(tranIsolation); |
| try { |
| connection.setTransactionIsolation(tranIsolationInt); |
| managedConnectionImpl.setLastTransactionIsolationLevel(tranIsolationInt); |
| } catch (SQLException sqle) { |
| _logger.log(SEVERE, "jdbc.exc_tx_iso", sqle); |
| throw new ResourceException("The transaction isolation could " + "not be set: " + sqle.getMessage()); |
| } |
| } |
| } |
| |
| /** |
| * Resets the isolation level for the <code>ManagedConnection</code> passed. If |
| * the transaction level is to be guaranteed to be the same as the one present |
| * when this <code>ManagedConnection</code> was created, as specified by the |
| * <code>ConnectionRequestInfo</code> passed, it sets the transaction isolation |
| * level from the <code>ConnectionRequestInfo</code> passed. Else, it sets it to |
| * the transaction isolation passed. |
| * |
| * @param managedConnectionImpl <code>ManagedConnection</code> |
| * @param tranIsol int |
| * @throws ResourceException if the isolation property is invalid or if the |
| * isolation cannot be set over the connection |
| */ |
| void resetIsolation(ManagedConnectionImpl managedConnectionImpl, int tranIsol) throws ResourceException { |
| Connection connection = managedConnectionImpl.getActualConnection(); |
| if (connection == null) { |
| return; |
| } |
| |
| String transactionIsolation = spec.getDetail(TRANSACTIONISOLATION); |
| if (transactionIsolation != null && !transactionIsolation.equals("")) { |
| String guaranteeIsolationLevel = spec.getDetail(GUARANTEEISOLATIONLEVEL); |
| |
| if (guaranteeIsolationLevel != null && !guaranteeIsolationLevel.equals("")) { |
| boolean guarantee = Boolean.valueOf(guaranteeIsolationLevel.toLowerCase(Locale.getDefault())); |
| |
| if (guarantee) { |
| int tranIsolationInt = getTransactionIsolationInt(transactionIsolation); |
| try { |
| if (tranIsolationInt != connection.getTransactionIsolation()) { |
| connection.setTransactionIsolation(tranIsolationInt); |
| } |
| } catch (SQLException sqle) { |
| _logger.log(SEVERE, "jdbc.exc_tx_iso", sqle); |
| throw new ResourceException("The isolation level could not be set: " + sqle.getMessage()); |
| } |
| } else { |
| try { |
| if (tranIsol != connection.getTransactionIsolation()) { |
| connection.setTransactionIsolation(tranIsol); |
| } |
| } catch (SQLException sqle) { |
| _logger.log(SEVERE, "jdbc.exc_tx_iso", sqle); |
| throw new ResourceException("The isolation level could not be set: " + sqle.getMessage()); |
| } |
| } |
| } |
| } |
| } |
| |
| private void detectSqlTraceListeners() { |
| // Check for sql-trace-listeners attribute. |
| String sqlTraceListeners = getSqlTraceListeners(); |
| String delimiter = ","; |
| |
| if (sqlTraceListeners != null && !sqlTraceListeners.equals("null")) { |
| sqlTraceDelegator = new SQLTraceDelegator(getPoolName(), getApplicationName(), getModuleName()); |
| StringTokenizer st = new StringTokenizer(sqlTraceListeners, delimiter); |
| |
| while (st.hasMoreTokens()) { |
| String sqlTraceListener = st.nextToken().trim(); |
| if (!sqlTraceListener.equals("")) { |
| Class listenerClass = null; |
| SQLTraceListener listener = null; |
| Constructor[] constructors = null; |
| Class[] parameterTypes = null; |
| Object[] initargs = null; |
| // Load the listener class |
| try { |
| listenerClass = Thread.currentThread().getContextClassLoader().loadClass(sqlTraceListener); |
| } catch (ClassNotFoundException ex) { |
| _logger.log(SEVERE, "jdbc.sql_trace_listener_cnfe", sqlTraceListener); |
| } |
| Class intf[] = listenerClass.getInterfaces(); |
| for (int i = 0; i < intf.length; i++) { |
| Class interfaceName = intf[i]; |
| if (interfaceName.getName().equals("org.glassfish.api.jdbc.SQLTraceListener")) { |
| |
| try { |
| |
| constructors = listenerClass.getConstructors(); |
| for (Constructor constructor : constructors) { |
| parameterTypes = constructor.getParameterTypes(); |
| // For now only the no argument constructors are allowed. |
| // TODO should this be documented? |
| if (parameterTypes.length == 0) { |
| listener = (SQLTraceListener) constructor.newInstance(initargs); |
| } |
| } |
| } catch (InstantiationException ex) { |
| _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage()); |
| } catch (IllegalAccessException ex) { |
| _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage()); |
| } catch (IllegalArgumentException ex) { |
| _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage()); |
| } catch (InvocationTargetException ex) { |
| _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage()); |
| } catch (SecurityException ex) { |
| _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage()); |
| } |
| sqlTraceDelegator.registerSQLTraceListener(listener); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Gets the integer equivalent of the string specifying the transaction |
| * isolation. |
| * |
| * @param tranIsolation string specifying the isolation level |
| * @return tranIsolationInt the <code>java.sql.Connection</code> constant for |
| * the string specifying the isolation. |
| */ |
| private int getTransactionIsolationInt(String tranIsolation) throws ResourceException { |
| if (tranIsolation.equalsIgnoreCase("read-uncommitted")) { |
| return Connection.TRANSACTION_READ_UNCOMMITTED; |
| } |
| |
| if (tranIsolation.equalsIgnoreCase("read-committed")) { |
| return Connection.TRANSACTION_READ_COMMITTED; |
| } |
| |
| if (tranIsolation.equalsIgnoreCase("repeatable-read")) { |
| return Connection.TRANSACTION_REPEATABLE_READ; |
| } |
| |
| if (tranIsolation.equalsIgnoreCase("serializable")) { |
| return Connection.TRANSACTION_SERIALIZABLE; |
| } |
| |
| throw new ResourceException( |
| "Invalid transaction isolation; the transaction " + |
| "isolation level can be empty or any of the following: " + |
| "read-uncommitted, read-committed, repeatable-read, serializable"); |
| } |
| |
| /** |
| * Common operation performed by all the child MCFs before returning a created |
| * mc |
| */ |
| protected void validateAndSetIsolation(ManagedConnectionImpl managedConnectionImpl) throws ResourceException { |
| try { |
| isValid(managedConnectionImpl); |
| setIsolation(managedConnectionImpl); |
| } catch (ResourceException e) { |
| if (managedConnectionImpl != null) { |
| try { |
| managedConnectionImpl.destroy(); |
| } catch (ResourceException e1) { |
| _logger.log(Level.WARNING, "jdbc.exc_destroy", e1); |
| } |
| } |
| |
| throw new ResourceAllocationException(localStrings.getString("jdbc.exc_destroy", e.getMessage()), e); |
| } |
| } |
| |
| private void detectStatementCachingSupport() { |
| String cacheSize = getStatementCacheSize(); |
| if (cacheSize != null) { |
| try { |
| statementCacheSize = Integer.parseInt(cacheSize); |
| // TODO-SC FINE log-level with Pool Name (if possible) |
| if (_logger.isLoggable(FINE)) { |
| _logger.log(FINE, "StatementCaching Size : " + statementCacheSize); |
| } |
| } catch (NumberFormatException nfe) { |
| if (_logger.isLoggable(FINE)) { |
| _logger.fine("Exception while setting StatementCacheSize : " + nfe.getMessage()); |
| } |
| // ignore |
| } |
| } |
| } |
| |
| /** |
| * Set the log writer for this <code>ManagedConnectionFactoryImpl</code> |
| * instance. |
| * |
| * @param out <code>PrintWriter</code> passed by the application server |
| * @see <code>getLogWriter</code> |
| */ |
| @Override |
| public void setLogWriter(java.io.PrintWriter out) { |
| logWriter = out; |
| } |
| |
| /** |
| * Set the associated <code>ResourceAdapterImpl</code> JavaBean. |
| * |
| * @param ra <code>ResourceAdapterImpl</code> associated with this |
| * <code>ManagedConnectionFactoryImpl</code> instance |
| * @see <code>getResourceAdapter</code> |
| */ |
| @Override |
| public void setResourceAdapter(jakarta.resource.spi.ResourceAdapter ra) { |
| this.resourceAdapter = ra; |
| } |
| |
| /** |
| * Sets the user name |
| * |
| * @param user <code>String</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "APP") |
| public void setUser(String user) { |
| spec.setDetail(DataSourceSpec.USERNAME, user); |
| } |
| |
| /** |
| * Gets the user name |
| * |
| * @return user |
| */ |
| public String getUser() { |
| return spec.getDetail(DataSourceSpec.USERNAME); |
| } |
| |
| /** |
| * Sets the password |
| * |
| * @param passwd <code>String</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "APP") |
| public void setPassword(String passwd) { |
| spec.setDetail(DataSourceSpec.PASSWORD, passwd); |
| } |
| |
| /** |
| * Gets the password |
| * |
| * @return passwd |
| */ |
| public String getPassword() { |
| return spec.getDetail(DataSourceSpec.PASSWORD); |
| } |
| |
| /** |
| * Sets the class name of the data source |
| * |
| * @param className <code>String</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "org.apache.derby.jdbc.ClientConnectionPoolDataSource") |
| public void setClassName(String className) { |
| spec.setDetail(DataSourceSpec.CLASSNAME, className); |
| } |
| |
| /** |
| * Gets the class name of the data source |
| * |
| * @return className |
| */ |
| public String getClassName() { |
| return spec.getDetail(DataSourceSpec.CLASSNAME); |
| } |
| |
| /** |
| * Sets if connection validation is required or not |
| * |
| * @param conVldReq <code>String</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "false") |
| public void setConnectionValidationRequired(String conVldReq) { |
| spec.setDetail(DataSourceSpec.CONNECTIONVALIDATIONREQUIRED, conVldReq); |
| } |
| |
| /** |
| * Returns if connection validation is required or not |
| * |
| * @return connection validation requirement |
| */ |
| public String getConnectionValidationRequired() { |
| return spec.getDetail(DataSourceSpec.CONNECTIONVALIDATIONREQUIRED); |
| } |
| |
| /** |
| * Sets the validation method required |
| * |
| * @param validationMethod <code>String</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "") |
| public void setValidationMethod(String validationMethod) { |
| spec.setDetail(VALIDATIONMETHOD, validationMethod); |
| } |
| |
| /** |
| * Returns the connection validation method type |
| * |
| * @return validation method |
| */ |
| public String getValidationMethod() { |
| return spec.getDetail(VALIDATIONMETHOD); |
| } |
| |
| /** |
| * Sets the table checked for during validation |
| * |
| * @param table <code>String</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "") |
| public void setValidationTableName(String table) { |
| spec.setDetail(DataSourceSpec.VALIDATIONTABLENAME, table); |
| } |
| |
| /** |
| * Returns the table checked for during validation |
| * |
| * @return table |
| */ |
| public String getValidationTableName() { |
| return spec.getDetail(DataSourceSpec.VALIDATIONTABLENAME); |
| } |
| |
| /** |
| * Sets the validation class name checked for during validation |
| * |
| * @param className <code>String</code> |
| */ |
| public void setValidationClassName(String className) { |
| try { |
| Class validationClass = Thread.currentThread().getContextClassLoader().loadClass(className); |
| boolean isAssignable = ConnectionValidation.class.isAssignableFrom(validationClass); |
| if (isAssignable) { |
| spec.setDetail(VALIDATIONCLASSNAME, className); |
| } else { |
| // Validation Failed |
| _logger.log(SEVERE, "jdbc.set_custom_validation_class_name_failure", className); |
| throw new ResourceException("The Custom validation class name is " |
| + "not valid as it does not implement " + ConnectionValidation.class.getName()); |
| } |
| } catch (ResourceException ex) { |
| _logger.log(SEVERE, "jdbc.set_custom_validation_class_name_failure", ex.getMessage()); |
| } catch (ClassNotFoundException ex) { |
| _logger.log(SEVERE, "jdbc.set_custom_validation_class_name_failure", ex.getMessage()); |
| } |
| } |
| |
| /** |
| * Returns the validation class name checked for during validation |
| * |
| * @return table |
| */ |
| public String getValidationClassName() { |
| return spec.getDetail(VALIDATIONCLASSNAME); |
| } |
| |
| /** |
| * Sets the transaction isolation level |
| * |
| * @param trnIsolation <code>String</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "") |
| public void setTransactionIsolation(String trnIsolation) { |
| spec.setDetail(TRANSACTIONISOLATION, trnIsolation); |
| } |
| |
| /** |
| * Returns the transaction isolation level |
| * |
| * @return transaction isolation level |
| */ |
| public String getTransactionIsolation() { |
| return spec.getDetail(TRANSACTIONISOLATION); |
| } |
| |
| /** |
| * Sets if the transaction isolation level is to be guaranteed |
| * |
| * @param guaranteeIsolation <code>String</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "") |
| public void setGuaranteeIsolationLevel(String guaranteeIsolation) { |
| spec.setDetail(GUARANTEEISOLATIONLEVEL, guaranteeIsolation); |
| } |
| |
| /** |
| * Returns the transaction isolation level |
| * |
| * @return isolation level guarantee |
| */ |
| public String getGuaranteeIsolationLevel() { |
| return spec.getDetail(GUARANTEEISOLATIONLEVEL); |
| } |
| |
| protected boolean isEqual(PasswordCredential pc, String user, String password) { |
| |
| // if equal get direct connection else |
| // get connection with user and password. |
| |
| String thisUser = (pc == null) ? null : pc.getUserName(); |
| char[] passwordArray = (pc == null) ? null : pc.getPassword(); |
| char[] tmpPasswordArray = (password == null) ? null : password.toCharArray(); |
| |
| return (isStringEqual(thisUser, user) && Arrays.equals(passwordArray, tmpPasswordArray)); |
| |
| } |
| |
| private boolean isStringEqual(String str1, String str2) { |
| return str1 == null ? str2 == null : str1.equals(str2); |
| } |
| |
| /** |
| * Sets the server name. |
| * |
| * @param serverName <code>String</code> |
| * @see <code>getServerName</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "localhost") |
| public void setServerName(String serverName) { |
| spec.setDetail(DataSourceSpec.SERVERNAME, serverName); |
| } |
| |
| /** |
| * Gets the server name. |
| * |
| * @return serverName |
| * @see <code>setServerName</code> |
| */ |
| public String getServerName() { |
| return spec.getDetail(DataSourceSpec.SERVERNAME); |
| } |
| |
| /** |
| * Sets the port number. |
| * |
| * @param portNumber <code>String</code> |
| * @see <code>getPortNumber</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "1527") |
| public void setPortNumber(String portNumber) { |
| spec.setDetail(DataSourceSpec.PORTNUMBER, portNumber); |
| } |
| |
| /** |
| * Gets the port number. |
| * |
| * @return portNumber |
| * @see <code>setPortNumber</code> |
| */ |
| public String getPortNumber() { |
| return spec.getDetail(DataSourceSpec.PORTNUMBER); |
| } |
| |
| public void setJdbc30DataSource(String booleanValue) { |
| spec.setDetail(DataSourceSpec.JDBC30DATASOURCE, booleanValue); |
| } |
| |
| public String getJdbc30DataSource() { |
| return spec.getDetail(DataSourceSpec.JDBC30DATASOURCE); |
| } |
| |
| /** |
| * Sets the database name. |
| * |
| * @param databaseName <code>String</code> |
| * @see <code>getDatabaseName</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "testdb") |
| public void setDatabaseName(String databaseName) { |
| spec.setDetail(DataSourceSpec.DATABASENAME, databaseName); |
| } |
| |
| /** |
| * Gets the database name. |
| * |
| * @return databaseName |
| * @see <code>setDatabaseName</code> |
| */ |
| public String getDatabaseName() { |
| return spec.getDetail(DataSourceSpec.DATABASENAME); |
| } |
| |
| /** |
| * Sets the data source name. |
| * |
| * @param dsn <code>String</code> |
| * @see <code>getDataSourceName</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "") |
| public void setDataSourceName(String dsn) { |
| spec.setDetail(DataSourceSpec.DATASOURCENAME, dsn); |
| } |
| |
| /** |
| * Gets the data source name. |
| * |
| * @return dsn |
| * @see <code>setDataSourceName</code> |
| */ |
| public String getDataSourceName() { |
| return spec.getDetail(DataSourceSpec.DATASOURCENAME); |
| } |
| |
| /** |
| * Set Statement Wrapping value |
| * |
| * @param wrapping <code>String</code> |
| * @see <code> getStatementWrapping </code> |
| */ |
| public void setStatementWrapping(String wrapping) { |
| spec.setDetail(DataSourceSpec.STATEMENTWRAPPING, wrapping); |
| computeStatementWrappingStatus(); |
| } |
| |
| /** |
| * Gets the statement wrapping value |
| * |
| * @return String representing "true" or "false" |
| * @see <code>setStatementWrapping</code> |
| */ |
| public String getStatementWrapping() { |
| return spec.getDetail(DataSourceSpec.STATEMENTWRAPPING); |
| } |
| |
| public void setStatementCacheSize(String value) { |
| spec.setDetail(DataSourceSpec.STATEMENTCACHESIZE, value); |
| detectStatementCachingSupport(); |
| } |
| |
| public String getStatementCacheSize() { |
| return spec.getDetail(DataSourceSpec.STATEMENTCACHESIZE); |
| } |
| |
| public void setStatementLeakTimeoutInSeconds(String value) { |
| spec.setDetail(DataSourceSpec.STATEMENTLEAKTIMEOUTINSECONDS, value); |
| detectStatementLeakSupport(); |
| } |
| |
| public String getStatementLeakTimeoutInSeconds() { |
| return spec.getDetail(DataSourceSpec.STATEMENTLEAKTIMEOUTINSECONDS); |
| } |
| |
| public void setStatementLeakReclaim(String value) { |
| spec.setDetail(DataSourceSpec.STATEMENTLEAKRECLAIM, value); |
| } |
| |
| public String getStatementLeakReclaim() { |
| return spec.getDetail(DataSourceSpec.STATEMENTLEAKRECLAIM); |
| } |
| |
| public void setPoolMonitoringSubTreeRoot(String value) { |
| spec.setDetail(DataSourceSpec.POOLMONITORINGSUBTREEROOT, value); |
| } |
| |
| public String getPoolMonitoringSubTreeRoot() { |
| return spec.getDetail(DataSourceSpec.POOLMONITORINGSUBTREEROOT); |
| } |
| |
| public String getApplicationName() { |
| return spec.getDetail(DataSourceSpec.APPLICATIONNAME); |
| } |
| |
| public void setApplicationName(String value) { |
| spec.setDetail(DataSourceSpec.APPLICATIONNAME, value); |
| } |
| |
| public String getModuleName() { |
| return spec.getDetail(DataSourceSpec.MODULENAME); |
| } |
| |
| public void setModuleName(String value) { |
| spec.setDetail(DataSourceSpec.MODULENAME, value); |
| } |
| |
| public String getPoolName() { |
| return spec.getDetail(DataSourceSpec.POOLNAME); |
| } |
| |
| public void setPoolName(String value) { |
| spec.setDetail(DataSourceSpec.POOLNAME, value); |
| } |
| |
| public String getStatementCacheType() { |
| return spec.getDetail(DataSourceSpec.STATEMENTCACHETYPE); |
| } |
| |
| public void setStatementCacheType(String statementCacheType) { |
| spec.setDetail(DataSourceSpec.STATEMENTCACHETYPE, statementCacheType); |
| this.statementCacheType = getStatementCacheType(); |
| if (this.statementCacheType == null || this.statementCacheType.trim().equals("")) { |
| if (_logger.isLoggable(FINE)) { |
| _logger.fine( |
| " Default StatementCaching Type : " + |
| localStrings.getString("jdbc.statement-cache.default.datastructure")); |
| } |
| } else { |
| if (_logger.isLoggable(FINE)) { |
| _logger.fine("StatementCaching Type : " + this.statementCacheType); |
| } |
| } |
| } |
| |
| public String getNumberOfTopQueriesToReport() { |
| return spec.getDetail(DataSourceSpec.NUMBEROFTOPQUERIESTOREPORT); |
| } |
| |
| public void setNumberOfTopQueriesToReport(String numTopQueriesToReport) { |
| spec.setDetail(DataSourceSpec.NUMBEROFTOPQUERIESTOREPORT, numTopQueriesToReport); |
| } |
| |
| public String getTimeToKeepQueriesInMinutes() { |
| return spec.getDetail(DataSourceSpec.TIMETOKEEPQUERIESINMINUTES); |
| } |
| |
| public void setTimeToKeepQueriesInMinutes(String timeToKeepQueries) { |
| spec.setDetail(DataSourceSpec.TIMETOKEEPQUERIESINMINUTES, timeToKeepQueries); |
| } |
| |
| public String getInitSql() { |
| return spec.getDetail(DataSourceSpec.INITSQL); |
| } |
| |
| public void setInitSql(String initSql) { |
| // TODO remove case where "null" is checked. Might be a CLI/GUI bug. |
| if (initSql != null && !initSql.equalsIgnoreCase("null") && !initSql.equals("")) { |
| spec.setDetail(DataSourceSpec.INITSQL, initSql); |
| } |
| } |
| |
| /** |
| * Set StatementTimeout value |
| * |
| * @param timeout <code>String</code> |
| * @see <code> getStatementTimeout </code> |
| */ |
| public void setStatementTimeout(String timeout) { |
| spec.setDetail(DataSourceSpec.STATEMENTTIMEOUT, timeout); |
| } |
| |
| /** |
| * Gets the StatementTimeout value |
| * |
| * @return String representing "true" or "false" |
| * @see <code>setStatementTimeout</code> |
| */ |
| public String getStatementTimeout() { |
| return spec.getDetail(DataSourceSpec.STATEMENTTIMEOUT); |
| } |
| |
| public String getSqlTraceListeners() { |
| return spec.getDetail(DataSourceSpec.SQLTRACELISTENERS); |
| } |
| |
| public void setSqlTraceListeners(String sqlTraceListeners) { |
| if (sqlTraceListeners != null) { |
| spec.setDetail(DataSourceSpec.SQLTRACELISTENERS, sqlTraceListeners); |
| detectSqlTraceListeners(); |
| } |
| } |
| |
| /** |
| * Sets the description. |
| * |
| * @param desc <code>String</code> |
| * @see <code>getDescription</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "Derby driver for datasource") |
| public void setDescription(String desc) { |
| spec.setDetail(DataSourceSpec.DESCRIPTION, desc); |
| } |
| |
| /** |
| * Gets the description. |
| * |
| * @return desc |
| * @see <code>setDescription</code> |
| */ |
| public String getDescription() { |
| return spec.getDetail(DataSourceSpec.DESCRIPTION); |
| } |
| |
| /** |
| * Sets the network protocol. |
| * |
| * @param nwProtocol <code>String</code> |
| * @see <code>getNetworkProtocol</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "") |
| public void setNetworkProtocol(String nwProtocol) { |
| spec.setDetail(DataSourceSpec.NETWORKPROTOCOL, nwProtocol); |
| } |
| |
| /** |
| * Gets the network protocol. |
| * |
| * @return nwProtocol |
| * @see <code>setNetworkProtocol</code> |
| */ |
| public String getNetworkProtocol() { |
| return spec.getDetail(DataSourceSpec.NETWORKPROTOCOL); |
| } |
| |
| /** |
| * Sets the role name. |
| * |
| * @param roleName <code>String</code> |
| * @see <code>getRoleName</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "") |
| public void setRoleName(String roleName) { |
| spec.setDetail(DataSourceSpec.ROLENAME, roleName); |
| } |
| |
| /** |
| * Gets the role name. |
| * |
| * @return roleName |
| * @see <code>setRoleName</code> |
| */ |
| public String getRoleName() { |
| return spec.getDetail(DataSourceSpec.ROLENAME); |
| } |
| |
| /** |
| * Sets the login timeout. |
| * |
| * @param loginTimeOut <code>String</code> |
| * @see <code>getLoginTimeOut</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "0") |
| public void setLoginTimeOut(String loginTimeOut) { |
| spec.setDetail(DataSourceSpec.LOGINTIMEOUT, loginTimeOut); |
| } |
| |
| /** |
| * Gets the login timeout. |
| * |
| * @return loginTimeout |
| * @see <code>setLoginTimeOut</code> |
| */ |
| public String getLoginTimeOut() { |
| return spec.getDetail(DataSourceSpec.LOGINTIMEOUT); |
| } |
| |
| /** |
| * Sets the delimiter. |
| * |
| * @param delim <code>String</code> |
| * @see <code>getDelimiter</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "#") |
| public void setDelimiter(String delim) { |
| spec.setDetail(DataSourceSpec.DELIMITER, delim); |
| } |
| |
| /** |
| * Gets the delimiter. |
| * |
| * @return delim |
| * @see <code>setDelimiter</code> |
| */ |
| public String getDelimiter() { |
| return spec.getDetail(DataSourceSpec.DELIMITER); |
| } |
| |
| public void setEscapeCharacter(String escapeCharacter) { |
| spec.setDetail(DataSourceSpec.ESCAPECHARACTER, escapeCharacter); |
| } |
| |
| public String getEscapeCharacter() { |
| return spec.getDetail(DataSourceSpec.ESCAPECHARACTER); |
| } |
| |
| /** |
| * Sets the driver specific properties. |
| * |
| * @param driverProps <code>String</code> |
| * @see <code>getDriverProperties</code> |
| */ |
| @ConfigProperty(type = String.class, defaultValue = "") |
| public void setDriverProperties(String driverProps) { |
| spec.setDetail(DataSourceSpec.DRIVERPROPERTIES, driverProps); |
| } |
| |
| /** |
| * Gets the driver specific properties. |
| * |
| * @return driverProps |
| * @see <code>setDriverProperties</code> |
| */ |
| public String getDriverProperties() { |
| return spec.getDetail(DataSourceSpec.DRIVERPROPERTIES); |
| } |
| |
| protected PoolInfo getPoolInfo() { |
| return new PoolInfo(getPoolName(), getApplicationName(), getModuleName()); |
| } |
| |
| protected ManagedConnectionImpl constructManagedConnection(PooledConnection pc, Connection sqlCon, |
| PasswordCredential passCred, ManagedConnectionFactoryImpl mcf) throws ResourceException { |
| return new ManagedConnectionImpl(pc, sqlCon, passCred, mcf, getPoolInfo(), statementCacheSize, |
| statementCacheType, sqlTraceDelegator, statementLeakTimeout, statementLeakReclaim); |
| } |
| |
| /** |
| * Returns the underlying datasource |
| * |
| * @return DataSource of jdbc vendor |
| * @throws ResourceException |
| */ |
| public Object getDataSource() throws ResourceException { |
| if (dataSourceObjectBuilder == null) { |
| dataSourceObjectBuilder = new DataSourceObjectBuilder(spec); |
| } |
| return dataSourceObjectBuilder.constructDataSourceObject(); |
| } |
| |
| protected static final int JVM_OPTION_STATEMENT_WRAPPING_ON = 1; |
| protected static final int JVM_OPTION_STATEMENT_WRAPPING_OFF = 0; |
| protected static final int JVM_OPTION_STATEMENT_WRAPPING_NOT_SET = -1; |
| |
| /** |
| * This wrapStatement flag is used to enable disable wrapping the statement |
| * objects. This can be enabled by passing jvm option, |
| * com.sun.appserv.jdbc.wrapstatement = true. This can be disabled by removing |
| * this option or by passing non true value. By default this will be disabled |
| */ |
| private static int wrapStatement = JVM_OPTION_STATEMENT_WRAPPING_NOT_SET; |
| |
| static { |
| wrapStatement = getStatementWrappingJVMOption(); |
| } |
| |
| /** |
| * Gets the Statement Wrapping JVM Option (available in 8.2)<br> |
| * Which will be deprecated in future versions. |
| * |
| * @return int representing the JVM Option value of statement wrapping. |
| */ |
| private static int getStatementWrappingJVMOption() { |
| int result = JVM_OPTION_STATEMENT_WRAPPING_NOT_SET; |
| String str = System.getProperty("com.sun.appserv.jdbc.wrapJdbcObjects"); |
| if ("true".equalsIgnoreCase(str)) { |
| result = JVM_OPTION_STATEMENT_WRAPPING_ON; |
| } else if ("false".equalsIgnoreCase(str)) { |
| result = JVM_OPTION_STATEMENT_WRAPPING_OFF; |
| } |
| return result; |
| } |
| |
| /** |
| * 9.1 has attribute "wrap-statements" which will be overridden when JVM option |
| * is specified as "true" or "false" JVM Option will be deprecated in future |
| * versions. |
| */ |
| protected void computeStatementWrappingStatus() { |
| |
| boolean poolProperty = false; |
| String statementWrappingString = getStatementWrapping(); |
| if (statementWrappingString != null) |
| poolProperty = Boolean.valueOf(statementWrappingString); |
| |
| if (wrapStatement == JVM_OPTION_STATEMENT_WRAPPING_ON |
| || (wrapStatement == JVM_OPTION_STATEMENT_WRAPPING_NOT_SET && poolProperty)) { |
| statementWrapping = true; |
| } else { |
| statementWrapping = false; |
| } |
| } |
| |
| /** |
| * Returns whether statement wrapping is enabled or not.<br> |
| * |
| * @return boolean representing statementwrapping status |
| */ |
| public boolean isStatementWrappingEnabled() { |
| return statementWrapping; |
| } |
| |
| public JdbcObjectsFactory getJdbcObjectsFactory() { |
| return jdbcObjectsFactory; |
| } |
| |
| protected void logFine(String logMessage) { |
| _logger.log(FINE, logMessage); |
| } |
| |
| @Override |
| public void mcfCreated() { |
| String poolMonitoringSubTreeRoot = getPoolMonitoringSubTreeRoot(); |
| String sqlTraceListeners = getSqlTraceListeners(); |
| |
| // Default values used in case sql tracing is OFF |
| int sqlTraceCacheSize = 0; |
| long timeToKeepQueries = 0; |
| if (sqlTraceListeners != null && !sqlTraceListeners.equals("null")) { |
| if (getNumberOfTopQueriesToReport() != null && !getNumberOfTopQueriesToReport().equals("null")) { |
| // Some value is set for this property |
| sqlTraceCacheSize = Integer.parseInt(getNumberOfTopQueriesToReport()); |
| } else { |
| // No property by this name. default to 10 queries |
| sqlTraceCacheSize = 10; |
| } |
| if (getTimeToKeepQueriesInMinutes() != null && !getTimeToKeepQueriesInMinutes().equals("null")) { |
| // Time-To-Keep-Queries property has been set |
| timeToKeepQueries = Integer.parseInt(getTimeToKeepQueriesInMinutes()); |
| } else { |
| // Default to 5 minutes after which cache is pruned. |
| timeToKeepQueries = 5; |
| // Time to keep queries is set to 5 minutes because the timer |
| // task will keep running till mcf is destroyed even if |
| // monitoring is turned OFF. |
| } |
| } |
| |
| _logger.finest("MCF Created"); |
| |
| if (statementCacheSize > 0 || (sqlTraceListeners != null && !sqlTraceListeners.equals("null")) |
| || statementLeakTimeout > 0) { |
| jdbcStatsProvider = new JdbcStatsProvider(getPoolName(), getApplicationName(), getModuleName(), |
| sqlTraceCacheSize, timeToKeepQueries); |
| |
| // Get the poolname and use it to initialize the stats provider n register |
| StatsProviderManager.register("jdbc-connection-pool", PluginPoint.SERVER, poolMonitoringSubTreeRoot, |
| jdbcStatsProvider); |
| |
| if (jdbcStatsProvider.getSqlTraceCache() != null) { |
| _logger.finest("Scheduling timer task for sql trace caching"); |
| Timer timer = ((ResourceAdapterImpl) resourceAdapter).getTimer(); |
| jdbcStatsProvider.getSqlTraceCache().scheduleTimerTask(timer); |
| } |
| |
| _logger.finest("Registered JDBCRA Stats Provider"); |
| } |
| } |
| |
| @Override |
| public void mcfDestroyed() { |
| _logger.finest("MCF Destroyed"); |
| |
| if (jdbcStatsProvider != null) { |
| if (jdbcStatsProvider.getSqlTraceCache() != null) { |
| _logger.finest("Canceling timer task for sql trace caching"); |
| jdbcStatsProvider.getSqlTraceCache().cancelTimerTask(); |
| } |
| |
| StatsProviderManager.unregister(jdbcStatsProvider); |
| jdbcStatsProvider = null; |
| _logger.finest("Unregistered JDBCRA Stats Provider"); |
| } |
| } |
| |
| private void detectStatementLeakSupport() { |
| String stmtLeakTimeout = getStatementLeakTimeoutInSeconds(); |
| String stmtLeakReclaim = getStatementLeakReclaim(); |
| if (stmtLeakTimeout != null) { |
| statementLeakTimeout = Integer.parseInt(stmtLeakTimeout) * 1000L; |
| statementLeakReclaim = Boolean.valueOf(stmtLeakReclaim); |
| if (_logger.isLoggable(FINE)) { |
| _logger.log(FINE, "StatementLeakTimeout in seconds: " + statementLeakTimeout |
| + " & StatementLeakReclaim: " + statementLeakReclaim + " for pool : " + getPoolInfo()); |
| } |
| } |
| } |
| |
| @Override |
| public void writeExternal(ObjectOutput out) throws IOException { |
| } |
| |
| @Override |
| public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { |
| resourceAdapter = ResourceAdapterImpl.getInstance(); |
| } |
| } |
