+++ /dev/null
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright [yyyy] [name of copyright owner]
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
\ No newline at end of file
+++ /dev/null
-Apache Tomcat JDBC Pool
-Copyright 2008-2016 The Apache Software Foundation
-
-This product includes software developed at
-The Apache Software Foundation (http://www.apache.org/).
-
+++ /dev/null
-# -----------------------------------------------------------------------------
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# -----------------------------------------------------------------------------
-# build.properties.sample
-#
-# This is an example "build.properties" file, used to customize building
-# Tomcat JDBC Pool for your local environment. It defines the location of all external
-# modules that Tomcat JDBC Pool depends on. Copy this file to "build.properties"
-# in the top-level source directory, and customize it as needed.
-# -----------------------------------------------------------------------------
-
-# ----- Vesion Control Flags -----
-version.major=1
-version.minor=1
-version.build=0
-version.patch=1
-version.suffix=
-
-# ----- Default Base Path for Dependent Packages -----
-# Please note this path must be absolute, not relative,
-# as it is referenced with different working directory
-# contexts by the various build scripts.
-base.path=${basedir}/includes
-
-compile.source=1.7
-compile.target=1.7
-compile.debug=true
-
-# Do not pass -deprecation (-Xlint:deprecation) flag to javac
-compile.deprecation=false
-
-# ----- Settings for Junit test database.
-
-# Common settings
-testdb.username=root
-testdb.password=password
-
-# H2
-testdb.url=jdbc:h2:~/.h2/test;QUERY_TIMEOUT=0;DB_CLOSE_ON_EXIT=TRUE;LOCK_TIMEOUT=50000;DEFAULT_LOCK_TIMEOUT=50000
-testdb.driverClassName=org.h2.Driver
-testdb.validationQuery=SELECT 1
-
-# MySQL
-#testdb.url=jdbc:mysql://localhost:3306/mysql?autoReconnect=true
-#testdb.driverClassName=com.mysql.jdbc.Driver
-#testdb.validationQuery=SELECT 1
-
-# Derby
-#testdb.url=jdbc:derby:derbyDB;create=true
-#testdb.driverClassName=org.apache.derby.jdbc.EmbeddedDriver
-#testdb.validationQuery=VALUES 1
-
-# JUnit Unit Test Suite
-junit.version=4.11
-junit.home=${base.path}/junit-${junit.version}
-junit.jar=${junit.home}/junit-${junit.version}.jar
-junit.loc=http://repo.maven.apache.org/maven2/junit/junit/${junit.version}/junit-${junit.version}.jar
-
-# Hamcrest Library, used by JUnit
-hamcrest.version=1.3
-hamcrest.home=${base.path}/hamcrest-${hamcrest.version}
-hamcrest.jar=${hamcrest.home}/hamcrest-core-${hamcrest.version}.jar
-hamcrest.loc=http://repo.maven.apache.org/maven2/org/hamcrest/hamcrest-core/${hamcrest.version}/hamcrest-core-${hamcrest.version}.jar
-
-mysql.home=${base.path}/mysql-connector-java-5.1.12
-mysql.jar=${mysql.home}/mysql-connector-java-5.1.12-bin.jar
-mysql.loc=http://mysql.mirrors.hoobly.com/Downloads/Connector-J/mysql-connector-java-5.1.12.zip
-
-tomcat.version=8.0.14
-tomcat.home=${base.path}/apache-tomcat-${tomcat.version}
-tomcat.dbcp.jar=${tomcat.home}/lib/tomcat-dbcp.jar
-tomcat.juli.jar=${tomcat.home}/bin/tomcat-juli.jar
-tomcat.loc=http://archive.apache.org/dist/tomcat/tomcat-8/v${tomcat.version}/bin/apache-tomcat-${tomcat.version}.zip
-
-tomcat.project.loc=http://svn.apache.org/repos/asf/tomcat/trunk/webapps/docs/project.xml
-tomcat.project.dest=${base.path}/project.xml
-
-tomcat.xsl.loc=http://svn.apache.org/repos/asf/tomcat/trunk/webapps/docs/tomcat-docs.xsl
-tomcat.xsl.dest=${base.path}/tomcat-docs.xsl
-
-derby.home=${base.path}/db-derby-10.5.1.1-bin
-derby.loc=http://archive.apache.org/dist/db/derby/db-derby-10.5.1.1/db-derby-10.5.1.1-bin.tar.gz
-derby.jar=${derby.home}/lib/derby.jar
-
-h2.home=${base.path}/h2
-h2.loc=http://h2database.googlecode.com/files/h2-2010-02-19.zip
-h2.jar=${h2.home}/bin/h2-1.2.129.jar
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements. See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<!DOCTYPE document [
- <!ENTITY project SYSTEM "@TOMCAT_PROJECT_DEST@">
-]>
-<?xml-stylesheet type="text/xsl" href="package.xsl"?>
-<document url="changelog.html">
-
- &project;
-
- <properties>
- <author email="fhanik@apache.org">Filip Hanik</author>
- <title>Changelog</title>
- </properties>
-
-<body>
-
-<section name="Tomcat JDBC Connection Pool - Apache Tomcat 7.0.19 and later">
- <p>
- Starting with Apache Tomcat 7.0.19 in July 2011, Tomcat JDBC Connection Pool
- is built and released as a component in official releases of Tomcat.
- The changes are now listed in "jdbc-pool" sections of Apache Tomcat
- changelog file. This changelog file is obsolete.
- </p>
-</section>
-
-<section name="Tomcat JDBC Connection Pool 1.1.0.0">
- <subsection name="pool">
- <changelog>
- <add><rev>1207712</rev> Pool cleaner should be a global thread, not spawn one thread per connection pool. (fhanik)</add>
- <fix><rev>1073531</rev> <bug>50805</bug> Only initialize connections once when async (fhanik)</fix>
- <fix><rev>1076380</rev> <bug>50857</bug> Correctly handle timeouts when the pool is busy when async (fhanik)</fix>
- <add>Added QueryTimeoutInterceptor to be able to configure timeouts on running queries automatically.</add>
- </changelog>
- </subsection>
-</section>
-
-<section name="Tomcat JDBC Connection Pool 1.0.9.4">
- <subsection name="pool">
- <changelog>
- <fix><rev>1069864</rev> <bug>50759</bug> Correctly set validation timestamp when using external validator.(fhanik)</fix>
- </changelog>
- </subsection>
-</section>
-
-<section name="Tomcat JDBC Connection Pool 1.0.9.3">
- <subsection name="pool">
- <changelog>
- <fix><rev>1060998</rev> <bug>50613</bug> Fix concurrency issue around pool size calculation.(fhanik)</fix>
- </changelog>
- </subsection>
-</section>
-<section name="Tomcat JDBC Connection Pool 1.0.9.2">
- <subsection name="pool">
- <changelog>
- <fix><rev>1057743</rev> Make sure passwords are masked.(fhanik)</fix>
- </changelog>
- </subsection>
-</section>
-<section name="Tomcat JDBC Connection Pool 1.0.9.0">
- <subsection name="pool">
- <changelog>
- <fix><rev>997321</rev> Ensure threads borrowing connections do not
- get stuck waiting for a new connection if a connection is released in
- another thread. (markt)</fix>
- <fix><rev>995432</rev> Make interceptor class names, property names
- and property values tolerant of whitespace by trimming the values before
- use. (markt)</fix>
- <fix><rev>995091</rev> <bug>49831</bug> Make sure pooled XAConnections are
- closed when the connection pool shuts down. Patch provided by Daniel
- Mikusa. (markt)</fix>
- <update><rev>995087</rev> Code clean-up. Remove some unused code. (markt)
- </update>
- <update><rev>995083</rev> Update to Tomcat 6.0.29 (for JULI). (markt)
- </update>
- <update><rev>992409</rev> Code clean-up. Reduce sequences of three or more
- blank lines to two blank lines. (markt)</update>
- <add><rev>952811</rev>, <rev>995095</rev> <bug>48814</bug> Add Validator
- interface and allow users to configure a Validator class name. Patch
- provided by Matt Passell. (markt)</add>
- <update><rev>948073</rev> Code clean-up. Remove unused imports. (markt)
- </update>
- <fix><rev>943434</rev> <bug>49224</bug> Only try setting the username and
- password if they are non-null. Patch provided by Matt Passell. (markt)
- </fix>
- <fix><rev>943032</rev> <bug>49269</bug> Set maxIdle to maxActive by
- default to prevent warning on start when maxIdle > maxActive. Patch
- provided by Matt Passell. (markt)</fix>
- <fix><rev>940574</rev> <bug>49241</bug> Don't ignore the
- suspectTimeout property. (fhanik)</fix>
- <fix><rev>939320</rev> Fix svn:keywords for property replacement.
- (kkolinko)</fix>
- <add><rev>931550</rev>, <rev>934651</rev>, <rev>934677</rev> Add a
- statement cache. (fhanik)</add>
- <update><rev>919076</rev> Improve XA support. (fhanik)</update>
- <fix><rev>915940</rev> <bug>48392</bug> Add an interceptor to wrap
- Statements and ResultSets to prevent access to the physical connection.
- (fhanik)</fix>
- <fix><rev>912026</rev> Call <code>setTransactionIsolation()</code> before
- anything else as some drivers require this to be the first call. (fhanik)
- </fix>
- <update><rev>900017</rev> Update Javadoc for XADataSource. (kkolinko)
- </update>
- </changelog>
- </subsection>
-</section>
-<section name="Tomcat JDBC Connection Pool prior to 1.0.9.0 (incomplete)">
- <subsection name="pool">
- <changelog>
- <update><rev>720253</rev> Document how to use interceptors</update>
- <update><rev>717972</rev> Added an interceptor that will clean up non closed statements when a connection is returned to the pool. (<code>org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer</code>)</update>
- <update><rev>713763</rev> Improve connection state handling</update>
- <fix><rev>713763</rev> Improve connection state handling</fix>
- </changelog>
- </subsection>
-</section>
-</body>
-</document>
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements. See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<!DOCTYPE document [
- <!ENTITY project SYSTEM "@TOMCAT_PROJECT_DEST@">
-]>
-<document url="jdbc-pool.html">
-
- &project;
-
- <properties>
- <author email="fhanik@apache.org">Filip Hanik</author>
- <title>The Tomcat JDBC Connection Pool</title>
- </properties>
-
-<body>
-
-<section name="Table of Contents">
-<toc/>
-</section>
-
-<section name="Introduction">
-
- <p>The <strong>JDBC Connection Pool <code>org.apache.tomcat.jdbc.pool</code></strong>
- is a replacement or an alternative to the <a href="http://commons.apache.org/dbcp/">Apache Commons DBCP</a>
- connection pool.</p>
-
- <p>So why do we need a new connection pool?</p>
-
- <p>Here are a few of the reasons:</p>
- <ol>
- <li>Commons DBCP 1.x is single threaded. In order to be thread safe
- Commons locks the entire pool for short periods during both object
- allocation and object return. Note that this does not apply to
- Commons DBCP 2.x.</li>
- <li>Commons DBCP 1.x can be slow. As the number of logical CPUs grows and
- the number of concurrent threads attempting to borrow or return
- objects increases, the performance suffers. For highly concurrent
- systems the impact can be significant. Note that this does not apply
- to Commons DBCP 2.x.</li>
- <li>Commons DBCP is over 60 classes. tomcat-jdbc-pool core is 8 classes,
- hence modifications for future requirement will require much less
- changes. This is all you need to run the connection pool itself, the
- rest is gravy.</li>
- <li>Commons DBCP uses static interfaces. This means you have to use the
- right version for a given JRE version or you may see
- <code>NoSuchMethodException</code> exceptions.</li>
- <li>It's not worth rewriting over 60 classes, when a connection pool can
- be accomplished with a much simpler implementation.</li>
- <li>Tomcat jdbc pool implements the ability retrieve a connection
- asynchronously, without adding additional threads to the library
- itself.</li>
- <li>Tomcat jdbc pool is a Tomcat module, it depends on Tomcat JULI, a
- simplified logging framework used in Tomcat.</li>
- <li>Retrieve the underlying connection using the
- <code>javax.sql.PooledConnection</code> interface.</li>
- <li>Starvation proof. If a pool is empty, and threads are waiting for a
- connection, when a connection is returned, the pool will awake the
- correct thread waiting. Most pools will simply starve.</li>
- </ol>
-
- <p>Features added over other connection pool implementations</p>
- <ol>
- <li>Support for highly concurrent environments and multi core/cpu systems.</li>
- <li>Dynamic implementation of interface, will support <code>java.sql</code> and <code>javax.sql</code> interfaces for
- your runtime environment (as long as your JDBC driver does the same), even when compiled with a lower version of the JDK.</li>
- <li>Validation intervals - we don't have to validate every single time we use the connection, we can do this
- when we borrow or return the connection, just not more frequent than an interval we can configure.</li>
- <li>Run-Once query, a configurable query that will be run only once, when the connection to the database is established.
- Very useful to setup session settings, that you want to exist during the entire time the connection is established.</li>
- <li>Ability to configure custom interceptors.
- This allows you to write custom interceptors to enhance the functionality. You can use interceptors to gather query stats,
- cache session states, reconnect the connection upon failures, retry queries, cache query results, and so on.
- Your options are endless and the interceptors are dynamic, not tied to a JDK version of a
- <code>java.sql</code>/<code>javax.sql</code> interface.</li>
- <li>High performance - we will show some differences in performance later on</li>
- <li>Extremely simple, due to the very simplified implementation, the line count and source file count are very low, compare with c3p0
- that has over 200 source files(last time we checked), Tomcat jdbc has a core of 8 files, the connection pool itself is about half
- that. As bugs may occur, they will be faster to track down, and easier to fix. Complexity reduction has been a focus from inception.</li>
- <li>Asynchronous connection retrieval - you can queue your request for a connection and receive a <code>Future<Connection></code> back.</li>
- <li>Better idle connection handling. Instead of closing connections directly, it can still pool connections and sizes the idle pool with a smarter algorithm.</li>
- <li>You can decide at what moment connections are considered abandoned, is it when the pool is full, or directly at a timeout
- by specifying a pool usage threshold.
- </li>
- <li>The abandon connection timer will reset upon a statement/query activity. Allowing a connections that is in use for a long time to not timeout.
- This is achieved using the <code>ResetAbandonedTimer</code>
- </li>
- <li>Close connections after they have been connected for a certain time. Age based close upon return to the pool.
- </li>
- <li>Get JMX notifications and log entries when connections are suspected for being abandoned. This is similar to
- the <code>removeAbandonedTimeout</code> but it doesn't take any action, only reports the information.
- This is achieved using the <code>suspectTimeout</code> attribute.</li>
- <li>Connections can be retrieved from a <code>java.sql.Driver</code>, <code>javax.sql.DataSource</code> or <code>javax.sql.XADataSource</code>
- This is achieved using the <code>dataSource</code> and <code>dataSourceJNDI</code> attributes.</li>
- <li>XA connection support</li>
- </ol>
-
-
-</section>
-<section name="How to use">
- <p>
- Usage of the Tomcat connection pool has been made to be as simple as possible, for those of you that are familiar with commons-dbcp, the
- transition will be very simple. Moving from other connection pools is also fairly straight forward.
- </p>
- <subsection name="Additional features">
- <p>The Tomcat connection pool offers a few additional features over what most other pools let you do:</p>
- <ul>
- <li><code>initSQL</code> - the ability to run a SQL statement exactly once, when the connection is created</li>
- <li><code>validationInterval</code> - in addition to running validations on connections, avoid running them too frequently.</li>
- <li><code>jdbcInterceptors</code> - flexible and pluggable interceptors to create any customizations around the pool,
- the query execution and the result set handling. More on this in the advanced section.</li>
- <li><code>fairQueue</code> - Set the fair flag to true to achieve thread fairness or to use asynchronous connection retrieval</li>
- </ul>
- </subsection>
- <subsection name="Inside the Apache Tomcat Container">
- <p>
- The Tomcat Connection pool is configured as a resource described in <a href="http://tomcat.apache.org/tomcat-8.0-doc/jndi-datasource-examples-howto.html" target="_blank">The Tomcat JDBC documentation</a>
- With the only difference being that you have to specify the <code>factory</code> attribute and set the value to
- <code>org.apache.tomcat.jdbc.pool.DataSourceFactory</code>
- </p>
- </subsection>
- <subsection name="Standalone">
- <p>
- The connection pool only has another dependency, and that is on tomcat-juli.jar.
- To configure the pool in a stand alone project using bean instantiation, the bean to instantiate is
- <code>org.apache.tomcat.jdbc.pool.DataSource</code>. The same attributes (documented below) as you use to configure a connection
- pool as a JNDI resource, are used to configure a data source as a bean.
- </p>
- </subsection>
- <subsection name="JMX">
- <p>
- The connection pool object exposes an MBean that can be registered.
- In order for the connection pool object to create the MBean, the flag <code>jmxEnabled</code> has to be set to true.
- This doesn't imply that the pool will be registered with an MBean server, merely that the MBean is created.
- In a container like Tomcat, Tomcat itself registers the DataSource with the MBean server, the
- <code>org.apache.tomcat.jdbc.pool.DataSource</code> object will then register the actual
- connection pool MBean.
- If you're running outside of a container, you can register the DataSource yourself under any object name you specify,
- and it propagates the registration to the underlying pool. To do this you would call <code>mBeanServer.registerMBean(dataSource.getPool().getJmxPool(),objectname)</code>.
- Prior to this call, ensure that the pool has been created by calling <code>dataSource.createPool()</code>.
- </p>
- </subsection>
-
-</section>
-<section name="Attributes">
- <p>To provide a very simple switch to and from commons-dbcp and tomcat-jdbc-pool,
- Most attributes are the same and have the same meaning.</p>
- <subsection name="JNDI Factory and Type">
- <attributes>
- <attribute name="factory" required="true">
- <p>factory is required, and the value should be <code>org.apache.tomcat.jdbc.pool.DataSourceFactory</code></p>
- </attribute>
- <attribute name="type" required="true">
- <p>Type should always be <code>javax.sql.DataSource</code> or <code>javax.sql.XADataSource</code></p>
- <p>Depending on the type a <code>org.apache.tomcat.jdbc.pool.DataSource</code> or a <code>org.apache.tomcat.jdbc.pool.XADataSource</code> will be created.</p>
- </attribute>
- </attributes>
- </subsection>
-
- <subsection name="System Properties">
- <p>System properties are JVM wide, affect all pools created in the JVM</p>
- <attributes>
- <attribute name="org.apache.tomcat.jdbc.pool.onlyAttemptCurrentClassLoader" required="false">
- <p>(boolean) Controls classloading of dynamic classes, such as
- JDBC drivers, interceptors and validators. If set to
- <code>false</code>, default value, the pool will first attempt
- to load using the current loader (i.e. the class loader that
- loaded the pool classes) and if class loading fails attempt to
- load using the thread context loader. Set this value to
- <code>true</code>, if you wish to remain backwards compatible
- with Apache Tomcat 8.0.8 and earlier, and only attempt the
- current loader.
- If not set then the default value is <code>false</code>.
- </p>
- </attribute>
- </attributes>
- </subsection>
-
- <subsection name="Common Attributes">
- <p>These attributes are shared between commons-dbcp and tomcat-jdbc-pool, in some cases default values are different.</p>
- <attributes>
-
- <attribute name="defaultAutoCommit" required="false">
- <p>(boolean) The default auto-commit state of connections created by this pool. If not set, default is JDBC driver default (If not set then the <code>setAutoCommit</code> method will not be called.)</p>
- </attribute>
-
- <attribute name="defaultReadOnly" required="false">
- <p>(boolean) The default read-only state of connections created by this pool. If not set then the <code>setReadOnly</code> method will not be called. (Some drivers don't support read only mode, ex: Informix)</p>
- </attribute>
-
- <attribute name="defaultTransactionIsolation" required="false">
- <p>(String) The default TransactionIsolation state of connections created by this pool. One of the following: (see javadoc )</p>
- <ul>
- <li><code>NONE</code></li>
- <li><code>READ_COMMITTED</code></li>
- <li><code>READ_UNCOMMITTED</code></li>
- <li><code>REPEATABLE_READ</code></li>
- <li><code>SERIALIZABLE</code></li>
- </ul>
- <p>If not set, the method will not be called and it defaults to the JDBC driver.</p>
- </attribute>
-
- <attribute name="defaultCatalog" required="false">
- <p>(String) The default catalog of connections created by this pool.</p>
- </attribute>
-
- <attribute name="driverClassName" required="true">
- <p>(String) The fully qualified Java class name of the JDBC driver to be used. The driver has to be accessible
- from the same classloader as tomcat-jdbc.jar
- </p>
- </attribute>
-
- <attribute name="username" required="true">
- <p>(String) The connection username to be passed to our JDBC driver to establish a connection.
- Note that method <code>DataSource.getConnection(username,password)</code>
- by default will not use credentials passed into the method,
- but will use the ones configured here. See <code>alternateUsernameAllowed</code>
- property for more details.
- </p>
- </attribute>
-
- <attribute name="password" required="true">
- <p>(String) The connection password to be passed to our JDBC driver to establish a connection.
- Note that method <code>DataSource.getConnection(username,password)</code>
- by default will not use credentials passed into the method,
- but will use the ones configured here. See <code>alternateUsernameAllowed</code>
- property for more details.
- </p>
- </attribute>
-
- <attribute name="maxActive" required="false">
- <p>(int) The maximum number of active connections that can be allocated from this pool at the same time.
- The default value is <code>100</code></p>
- </attribute>
-
- <attribute name="maxIdle" required="false">
- <p>(int) The maximum number of connections that should be kept in the pool at all times.
- Default value is <code>maxActive</code>:<code>100</code>
- Idle connections are checked periodically (if enabled) and
- connections that been idle for longer than <code>minEvictableIdleTimeMillis</code>
- will be released. (also see <code>testWhileIdle</code>)</p>
- </attribute>
-
- <attribute name="minIdle" required="false">
- <p>
- (int) The minimum number of established connections that should be kept in the pool at all times.
- The connection pool can shrink below this number if validation queries fail.
- Default value is derived from <code>initialSize</code>:<code>10</code> (also see <code>testWhileIdle</code>)
- </p>
- </attribute>
-
- <attribute name="initialSize" required="false">
- <p>(int)The initial number of connections that are created when the pool is started.
- Default value is <code>10</code></p>
- </attribute>
-
- <attribute name="maxWait" required="false">
- <p>(int) The maximum number of milliseconds that the pool will wait (when there are no available connections)
- for a connection to be returned before throwing an exception.
- Default value is <code>30000</code> (30 seconds)</p>
- </attribute>
-
- <attribute name="testOnBorrow" required="false">
- <p>(boolean) The indication of whether objects will be validated before being borrowed from the pool.
- If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another.
- NOTE - for a true value to have any effect, the <code>validationQuery</code>
- or <code>validatorClassName</code> parameter must be set to a non-null string.
- In order to have a more efficient validation, see <code>validationInterval</code>.
- Default value is <code>false</code>
- </p>
- </attribute>
-
- <attribute name="testOnConnect" required="false">
- <p>(boolean) The indication of whether objects will be validated when a connection is first created.
- If an object fails to validate, it will be throw <code>SQLException</code>.
- NOTE - for a true value to have any effect, the <code>validationQuery</code>, <code>initSQL</code>
- or <code>validatorClassName</code> parameter must be set to a non-null string.
- Default value is <code>false</code>
- </p>
- </attribute>
-
- <attribute name="testOnReturn" required="false">
- <p>(boolean) The indication of whether objects will be validated before being returned to the pool.
- NOTE - for a true value to have any effect, the <code>validationQuery</code>
- or <code>validatorClassName</code> parameter must be set to a non-null string.
- The default value is <code>false</code>.
- </p>
- </attribute>
-
- <attribute name="testWhileIdle" required="false">
- <p>(boolean) The indication of whether objects will be validated by the idle object evictor (if any).
- If an object fails to validate, it will be dropped from the pool.
- NOTE - for a true value to have any effect, the <code>validationQuery</code>
- or <code>validatorClassName</code> parameter must be set to a non-null string.
- The default value is <code>false</code> and this property has to be set in order for the
- pool cleaner/test thread is to run (also see <code>timeBetweenEvictionRunsMillis</code>)
- </p>
- </attribute>
-
- <attribute name="validationQuery" required="false">
- <p>(String) The SQL query that will be used to validate connections from this pool before returning them to the caller.
- If specified, this query does not have to return any data, it just can't throw a <code>SQLException</code>.
- The default value is <code>null</code>.
- Example values are <code>SELECT 1</code>(mysql), <code>select 1 from dual</code>(oracle), <code>SELECT 1</code>(MS Sql Server)
- </p>
- </attribute>
-
- <attribute name="validationQueryTimeout" required="false">
- <p>(int) The timeout in seconds before a connection validation queries fail. This works by calling
- <code>java.sql.Statement.setQueryTimeout(seconds)</code> on the statement that executes the <code>validationQuery</code>.
- The pool itself doesn't timeout the query, it is still up to the JDBC driver to enforce query timeouts.
- A value less than or equal to zero will disable this feature.
- The default value is <code>-1</code>.
- </p>
- </attribute>
-
- <attribute name="validatorClassName" required="false">
- <p>(String) The name of a class which implements the
- <code>org.apache.tomcat.jdbc.pool.Validator</code> interface and
- provides a no-arg constructor (may be implicit). If specified, the
- class will be used to create a Validator instance which is then used
- instead of any validation query to validate connections. The default
- value is <code>null</code>. An example value is
- <code>com.mycompany.project.SimpleValidator</code>.
- </p>
- </attribute>
-
- <attribute name="timeBetweenEvictionRunsMillis" required="false">
- <p>(int) The number of milliseconds to sleep between runs of the idle connection validation/cleaner thread.
- This value should not be set under 1 second. It dictates how often we check for idle, abandoned connections, and how often
- we validate idle connections.
- The default value is <code>5000</code> (5 seconds). <br/>
- </p>
- </attribute>
-
- <attribute name="numTestsPerEvictionRun" required="false">
- <p>(int) Property not used in tomcat-jdbc-pool.</p>
- </attribute>
-
- <attribute name="minEvictableIdleTimeMillis" required="false">
- <p>(int) The minimum amount of time an object may sit idle in the pool before it is eligible for eviction.
- The default value is <code>60000</code> (60 seconds).</p>
- </attribute>
-
- <attribute name="accessToUnderlyingConnectionAllowed" required="false">
- <p>(boolean) Property not used. Access can be achieved by calling <code>unwrap</code> on the pooled connection.
- see <code>javax.sql.DataSource</code> interface, or call <code>getConnection</code> through reflection or
- cast the object as <code>javax.sql.PooledConnection</code></p>
- </attribute>
-
- <attribute name="removeAbandoned" required="false">
- <p>(boolean) Flag to remove abandoned connections if they exceed the <code>removeAbandonedTimeout</code>.
- If set to true a connection is considered abandoned and eligible for removal if it has been in use
- longer than the <code>removeAbandonedTimeout</code> Setting this to <code>true</code> can recover db connections from
- applications that fail to close a connection. See also <code>logAbandoned</code>
- The default value is <code>false</code>.</p>
- </attribute>
-
- <attribute name="removeAbandonedTimeout" required="false">
- <p>(int) Timeout in seconds before an abandoned(in use) connection can be removed.
- The default value is <code>60</code> (60 seconds). The value should be set to the longest running query your applications
- might have.</p>
- </attribute>
-
- <attribute name="logAbandoned" required="false">
- <p>(boolean) Flag to log stack traces for application code which abandoned a Connection.
- Logging of abandoned Connections adds overhead for every Connection borrow because a stack trace has to be generated.
- The default value is <code>false</code>.</p>
- </attribute>
-
- <attribute name="connectionProperties" required="false">
- <p>(String) The connection properties that will be sent to our JDBC driver when establishing new connections.
- Format of the string must be [propertyName=property;]*
- NOTE - The "user" and "password" properties will be passed explicitly, so they do not need to be included here.
- The default value is <code>null</code>.</p>
- </attribute>
-
- <attribute name="poolPreparedStatements" required="false">
- <p>(boolean) Property not used.</p>
- </attribute>
-
- <attribute name="maxOpenPreparedStatements" required="false">
- <p>(int) Property not used.</p>
- </attribute>
-
- </attributes>
-
- </subsection>
-
- <subsection name="Tomcat JDBC Enhanced Attributes">
-
- <attributes>
-
- <attribute name="initSQL" required="false">
- <p>(String) A custom query to be run when a connection is first created.
- The default value is <code>null</code>.</p>
- </attribute>
-
- <attribute name="jdbcInterceptors" required="false">
- <p>(String) A semicolon separated list of classnames extending
- <code>org.apache.tomcat.jdbc.pool.JdbcInterceptor</code> class.
- See <a href="#Configuring_JDBC_interceptors">Configuring JDBC interceptors</a>
- below for more detailed description of syntaz and examples.
- </p>
- <p>
- These interceptors will be inserted as an interceptor into the chain
- of operations on a <code>java.sql.Connection</code> object.
- The default value is <code>null</code>.
- </p>
- <p>
- Predefined interceptors:<br/>
- <code>org.apache.tomcat.jdbc.pool.interceptor.<br />ConnectionState</code>
- - keeps track of auto commit, read only, catalog and transaction isolation level.<br/>
- <code>org.apache.tomcat.jdbc.pool.interceptor.<br />StatementFinalizer</code>
- - keeps track of opened statements, and closes them when the connection is returned to the pool.
- </p>
- <p>
- More predefined interceptors are described in detail in the
- <a href="#JDBC_interceptors">JDBC Interceptors section</a>.
- </p>
- </attribute>
-
- <attribute name="validationInterval" required="false">
- <p>(long) avoid excess validation, only run validation at most at this frequency - time in milliseconds.
- If a connection is due for validation, but has been validated previously within this interval, it will not be validated again.
- The default value is <code>3000</code> (3 seconds).</p>
- </attribute>
-
- <attribute name="jmxEnabled" required="false">
- <p>(boolean) Register the pool with JMX or not.
- The default value is <code>true</code>.</p>
- </attribute>
-
- <attribute name="fairQueue" required="false">
- <p>(boolean) Set to true if you wish that calls to getConnection should be treated
- fairly in a true FIFO fashion. This uses the <code>org.apache.tomcat.jdbc.pool.FairBlockingQueue</code>
- implementation for the list of the idle connections. The default value is <code>true</code>.
- This flag is required when you want to use asynchronous connection retrieval.<br/>
- Setting this flag ensures that threads receive connections in the order they arrive.<br/>
- During performance tests, there is a very large difference in how locks
- and lock waiting is implemented. When <code>fairQueue=true</code>
- there is a decision making process based on what operating system the system is running.
- If the system is running on Linux (property <code>os.name=Linux</code>.
- To disable this Linux specific behavior and still use the fair queue, simply add the property
- <code>org.apache.tomcat.jdbc.pool.FairBlockingQueue.ignoreOS=true</code> to your system properties
- before the connection pool classes are loaded.
- </p>
- </attribute>
-
- <attribute name="abandonWhenPercentageFull" required="false">
- <p>(int) Connections that have been abandoned (timed out) wont get closed and reported up unless
- the number of connections in use are above the percentage defined by <code>abandonWhenPercentageFull</code>.
- The value should be between 0-100.
- The default value is <code>0</code>, which implies that connections are eligible for closure as soon
- as <code>removeAbandonedTimeout</code> has been reached.</p>
- </attribute>
-
- <attribute name="maxAge" required="false">
- <p>(long) Time in milliseconds to keep this connection. This attribute
- works both when returning connection and when borrowing connection.
- When a connection is borrowed from the pool, the pool will check to see
- if the <code>now - time-when-connected > maxAge</code> has been reached
- , and if so, it reconnects before borrow it. When a connection is
- returned to the pool, the pool will check to see if the
- <code>now - time-when-connected > maxAge</code> has been reached, and
- if so, it closes the connection rather than returning it to the pool.
- The default value is <code>0</code>, which implies that connections
- will be left open and no age check will be done upon borrowing from the
- pool and returning the connection to the pool.</p>
- </attribute>
-
- <attribute name="useEquals" required="false">
- <p>(boolean) Set to true if you wish the <code>ProxyConnection</code> class to use <code>String.equals</code> and set to <code>false</code>
- when you wish to use <code>==</code> when comparing method names. This property does not apply to added interceptors as those are configured individually.
- The default value is <code>true</code>.
- </p>
- </attribute>
- <attribute name="suspectTimeout" required="false">
- <p>(int) Timeout value in seconds. Default value is <code>0</code>.<br/>
- Similar to to the <code>removeAbandonedTimeout</code> value but instead of treating the connection
- as abandoned, and potentially closing the connection, this simply logs the warning if
- <code>logAbandoned</code> is set to true. If this value is equal or less than 0, no suspect
- checking will be performed. Suspect checking only takes place if the timeout value is larger than 0 and
- the connection was not abandoned or if abandon check is disabled. If a connection is suspect a WARN message gets
- logged and a JMX notification gets sent once.
- </p>
- </attribute>
- <attribute name="rollbackOnReturn" required="false">
- <p>(boolean) If <code>autoCommit==false</code> then the pool can terminate the transaction by calling rollback on the connection as it is returned to the pool
- Default value is <code>false</code>.<br/>
- </p>
- </attribute>
- <attribute name="commitOnReturn" required="false">
- <p>(boolean) If <code>autoCommit==false</code> then the pool can complete the transaction by calling commit on the connection as it is returned to the pool
- If <code>rollbackOnReturn==true</code> then this attribute is ignored.
- Default value is <code>false</code>.<br/>
- </p>
- </attribute>
- <attribute name="alternateUsernameAllowed" required="false">
- <p>(boolean) By default, the jdbc-pool will ignore the
- <a href="http://docs.oracle.com/javase/6/docs/api/javax/sql/DataSource.html#getConnection(java.lang.String,%20java.lang.String)"><code>DataSource.getConnection(username,password)</code></a>
- call, and simply return a previously pooled connection under the globally configured properties <code>username</code> and <code>password</code>, for performance reasons.
- </p>
- <p>
- The pool can however be configured to allow use of different credentials
- each time a connection is requested. To enable the functionality described in the
- <a href="http://docs.oracle.com/javase/6/docs/api/javax/sql/DataSource.html#getConnection(java.lang.String,%20java.lang.String)"><code>DataSource.getConnection(username,password)</code></a>
- call, simply set the property <code>alternateUsernameAllowed</code>
- to <code>true</code>.<br />
- Should you request a connection with the credentials user1/password1 and the connection
- was previously connected using different user2/password2, the connection will be closed,
- and reopened with the requested credentials. This way, the pool size is still managed
- on a global level, and not on a per schema level. <br/>
- The default value is <code>false</code>.<br/>
- This property was added as an enhancement to <a href="https://bz.apache.org/bugzilla/show_bug.cgi?id=50025">bug 50025</a>.
- </p>
- </attribute>
- <attribute name="dataSource" required="false">
- <p>(javax.sql.DataSource) Inject a data source to the connection pool, and the pool will use the data source to retrieve connections instead of establishing them using the <code>java.sql.Driver</code> interface.
- This is useful when you wish to pool XA connections or connections established using a data source instead of a connection string. Default value is <code>null</code>
- </p>
- </attribute>
- <attribute name="dataSourceJNDI" required="false">
- <p>(String) The JNDI name for a data source to be looked up in JNDI and then used to establish connections to the database. See the <code>dataSource</code> attribute. Default value is <code>null</code>
- </p>
- </attribute>
- <attribute name="useDisposableConnectionFacade" required="false">
- <p>(boolean) Set this to true if you wish to put a facade on your connection so that it cannot be reused after it has been closed. This prevents a thread holding on to a
- reference of a connection it has already called closed on, to execute queries on it. Default value is <code>true</code>.
- </p>
- </attribute>
- <attribute name="logValidationErrors" required="false">
- <p>(boolean) Set this to true to log errors during the validation phase to the log file. If set to true, errors will be logged as SEVERE. Default value is <code>false</code> for backwards compatibility.
- </p>
- </attribute>
- <attribute name="propagateInterruptState" required="false">
- <p>(boolean) Set this to true to propagate the interrupt state for a thread that has been interrupted (not clearing the interrupt state). Default value is <code>false</code> for backwards compatibility.
- </p>
- </attribute>
- <attribute name="ignoreExceptionOnPreLoad" required="false">
- <p>(boolean) Flag whether ignore error of connection creation while initializing the pool.
- Set to true if you want to ignore error of connection creation while initializing the pool.
- Set to false if you want to fail the initialization of the pool by throwing exception.
- The default value is <code>false</code>.
- </p>
- </attribute>
-
- </attributes>
- </subsection>
-</section>
-<section name="Advanced usage">
- <subsection name="JDBC interceptors">
- <p>To see an example of how to use an interceptor, take a look at
- <code>org.apache.tomcat.jdbc.pool.interceptor.ConnectionState</code>.
- This simple interceptor is a cache of three attributes, transaction isolation level, auto commit and read only state,
- in order for the system to avoid not needed roundtrips to the database.
- </p>
- <p>Further interceptors will be added to the core of the pool as the need arises. Contributions are always welcome!</p>
- <p>Interceptors are of course not limited to just <code>java.sql.Connection</code> but can be used to wrap any
- of the results from a method invokation as well. You could build query performance analyzer that provides JMX notifications when a
- query is running longer than the expected time.</p>
- </subsection>
- <subsection name="Configuring JDBC interceptors">
- <p>Configuring JDBC interceptors is done using the <b>jdbcInterceptors</b> property.
- The property contains a list of semicolon separated class names. If the
- classname is not fully qualified it will be prefixed with the
- <code>org.apache.tomcat.jdbc.pool.interceptor.</code> prefix.
- </p>
- <p>Example:<br/>
- <code>
- jdbcInterceptors="org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;
- org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer"
- </code>
- <br/>
- is the same as
- <br/>
- <code> jdbcInterceptors="ConnectionState;StatementFinalizer"</code>
- </p>
- <p>
- Interceptors can have properties as well. Properties for an interceptor
- are specified within parentheses after the class name. Several properties
- are separated by commas.
- </p>
- <p>Example:<br/>
- <code>
- jdbcInterceptors="ConnectionState;StatementFinalizer(useEquals=true)"
- </code>
- </p>
- <p>
- Extra whitespace characters around class names, property names and values
- are ignored.
- </p>
- </subsection>
- <subsection name="org.apache.tomcat.jdbc.pool.JdbcInterceptor">
- <p>Abstract base class for all interceptors, cannot be instantiated.</p>
- <attributes>
- <attribute name="useEquals" required="false">
- <p>(boolean) Set to true if you wish the <code>ProxyConnection</code> class to use <code>String.equals</code> and set to <code>false</code>
- when you wish to use <code>==</code> when comparing method names.
- The default value is <code>true</code>.
- </p>
- </attribute>
- </attributes>
- </subsection>
- <subsection name="org.apache.tomcat.jdbc.pool.interceptor.ConnectionState">
- <p>Caches the connection for the following attributes <code>autoCommit</code>, <code>readOnly</code>,
- <code>transactionIsolation</code> and <code>catalog</code>.
- It is a performance enhancement to avoid roundtrip to the database when getters are called or setters are called with an already set value.
- </p>
- <attributes>
- </attributes>
- </subsection>
- <subsection name="org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer">
- <p>Keeps track of all statements created using <code>createStatement</code>, <code>prepareStatement</code> or <code>prepareCall</code>
- and closes these statements when the connection is returned to the pool.
- </p>
- <attributes>
- <attribute name="trace" required="false">
- <p>(boolean as String) Enable tracing of unclosed statements.
- When enabled and a connection is closed, and statements are not closed,
- the interceptor will log all stack traces.
- The default value is <code>false</code>.
- </p>
- </attribute>
- </attributes>
- </subsection>
- <subsection name="org.apache.tomcat.jdbc.pool.interceptor.StatementCache">
- <p>Caches <code>PreparedStatement</code> and/or <code>CallableStatement</code>
- instances on a connection.
- </p>
- <p>The statements are cached per connection.
- The count limit is counted globally for all connections that belong to
- the same pool. Once the count reaches <code>max</code>, subsequent
- statements are not returned to the cache and are closed immediately.
- </p>
- <attributes>
- <attribute name="prepared" required="false">
- <p>(boolean as String) Enable caching of <code>PreparedStatement</code>
- instances created using <code>prepareStatement</code> calls.
- The default value is <code>true</code>.
- </p>
- </attribute>
- <attribute name="callable" required="false">
- <p>(boolean as String) Enable caching of <code>CallableStatement</code>
- instances created using <code>prepareCall</code> calls.
- The default value is <code>false</code>.
- </p>
- </attribute>
- <attribute name="max" required="false">
- <p>(int as String) Limit on the count of cached statements across
- the connection pool.
- The default value is <code>50</code>.
- </p>
- </attribute>
- </attributes>
- </subsection>
- <subsection name="org.apache.tomcat.jdbc.pool.interceptor.StatementDecoratorInterceptor">
- <p>See <bug>48392</bug>. Interceptor to wrap statements and result sets in order to prevent access to the actual connection
- using the methods <code>ResultSet.getStatement().getConnection()</code> and <code>Statement.getConnection()</code>
- </p>
- <attributes>
- </attributes>
- </subsection>
- <subsection name="org.apache.tomcat.jdbc.pool.interceptor.QueryTimeoutInterceptor">
- <p>Automatically calls <code>java.sql.Statement.setQueryTimeout(seconds)</code> when a new statement is created.
- The pool itself doesn't timeout the query, it is still up to the JDBC driver to enforce query timeouts.
- </p>
- <attributes>
- <attribute name="queryTimeout" required="true">
- <p>(int as String) The number of seconds to set for the query timeout.
- A value less than or equal to zero will disable this feature.
- The default value is <code>1</code> seconds.
- </p>
- </attribute>
- </attributes>
- </subsection>
- <subsection name="org.apache.tomcat.jdbc.pool.interceptor.SlowQueryReport">
- <p>Keeps track of query performance and issues log entries when queries exceed a time threshold of fail.
- The log level used is <code>WARN</code>
- </p>
- <attributes>
- <attribute name="threshold" required="false">
- <p>(int as String) The number of milliseconds a query has to exceed before issuing a log alert.
- The default value is <code>1000</code> milliseconds.
- </p>
- </attribute>
- <attribute name="maxQueries" required="false">
- <p>(int as String) The maximum number of queries to keep track of in order to preserve memory space.
- A value less than or equal to 0 will disable this feature.
- The default value is <code>1000</code>.
- </p>
- </attribute>
- <attribute name="logSlow" required="false">
- <p>(boolean as String) Set to <code>true</code> if you wish to log slow queries.
- The default value is <code>true</code>.
- </p>
- </attribute>
- <attribute name="logFailed" required="false">
- <p>(boolean as String) Set to <code>true</code> if you wish to log failed queries.
- The default value is <code>false</code>.
- </p>
- </attribute>
- </attributes>
- </subsection>
- <subsection name="org.apache.tomcat.jdbc.pool.interceptor.SlowQueryReportJmx">
- <p>Extends the <code>SlowQueryReport</code> and in addition to log entries it issues JMX notification
- for monitoring tools to react to. Inherits all the attributes from its parent class.
- This class uses Tomcat's JMX engine so it wont work outside of the Tomcat container.
- By default, JMX notifications are sent through the ConnectionPool mbean if it is enabled.
- The <code>SlowQueryReportJmx</code> can also register an MBean if <code>notifyPool=false</code>
- </p>
- <attributes>
- <attribute name="notifyPool" required="false">
- <p>(boolean as String) Set to false if you want JMX notifications to go to the <code>SlowQueryReportJmx</code> MBean
- The default value is <code>true</code>.
- </p>
- </attribute>
- <attribute name="objectName" required="false">
- <p>(String) Define a valid <code>javax.management.ObjectName</code> string that will be used to register this object with the platform mbean server
- The default value is <code>null</code> and the object will be registered using
- tomcat.jdbc:type=org.apache.tomcat.jdbc.pool.interceptor.SlowQueryReportJmx,name=the-name-of-the-pool
- </p>
- </attribute>
- </attributes>
- </subsection>
- <subsection name="org.apache.tomcat.jdbc.pool.interceptor.ResetAbandonedTimer">
- <p>
- The abandoned timer starts when a connection is checked out from the pool.
- This means if you have a 30second timeout and run 10x10second queries using the connection
- it will be marked abandoned and potentially reclaimed depending on the <code>abandonWhenPercentageFull</code>
- attribute.
- Using this interceptor it will reset the checkout timer every time you perform an operation on the connection or execute a
- query successfully.
- </p>
- <attributes>
- </attributes>
- </subsection>
-</section>
-
-<section name="Code Example">
- <p>Other examples of Tomcat configuration for JDBC usage can be found <a href="http://tomcat.apache.org/tomcat-8.0-doc/jndi-datasource-examples-howto.html">in the Tomcat documentation</a>. </p>
- <subsection name="Plain Ol' Java">
- <p>Here is a simple example of how to create and use a data source.</p>
-<source><![CDATA[ import java.sql.Connection;
- import java.sql.ResultSet;
- import java.sql.Statement;
-
- import org.apache.tomcat.jdbc.pool.DataSource;
- import org.apache.tomcat.jdbc.pool.PoolProperties;
-
- public class SimplePOJOExample {
-
- public static void main(String[] args) throws Exception {
- PoolProperties p = new PoolProperties();
- p.setUrl("jdbc:mysql://localhost:3306/mysql");
- p.setDriverClassName("com.mysql.jdbc.Driver");
- p.setUsername("root");
- p.setPassword("password");
- p.setJmxEnabled(true);
- p.setTestWhileIdle(false);
- p.setTestOnBorrow(true);
- p.setValidationQuery("SELECT 1");
- p.setTestOnReturn(false);
- p.setValidationInterval(30000);
- p.setTimeBetweenEvictionRunsMillis(30000);
- p.setMaxActive(100);
- p.setInitialSize(10);
- p.setMaxWait(10000);
- p.setRemoveAbandonedTimeout(60);
- p.setMinEvictableIdleTimeMillis(30000);
- p.setMinIdle(10);
- p.setLogAbandoned(true);
- p.setRemoveAbandoned(true);
- p.setJdbcInterceptors(
- "org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;"+
- "org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer");
- DataSource datasource = new DataSource();
- datasource.setPoolProperties(p);
-
- Connection con = null;
- try {
- con = datasource.getConnection();
- Statement st = con.createStatement();
- ResultSet rs = st.executeQuery("select * from user");
- int cnt = 1;
- while (rs.next()) {
- System.out.println((cnt++)+". Host:" +rs.getString("Host")+
- " User:"+rs.getString("User")+" Password:"+rs.getString("Password"));
- }
- rs.close();
- st.close();
- } finally {
- if (con!=null) try {con.close();}catch (Exception ignore) {}
- }
- }
-
- }]]></source>
- </subsection>
- <subsection name="As a Resource">
- <p>And here is an example on how to configure a resource for JNDI lookups</p>
-<source><![CDATA[<Resource name="jdbc/TestDB"
- auth="Container"
- type="javax.sql.DataSource"
- factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"
- testWhileIdle="true"
- testOnBorrow="true"
- testOnReturn="false"
- validationQuery="SELECT 1"
- validationInterval="30000"
- timeBetweenEvictionRunsMillis="30000"
- maxActive="100"
- minIdle="10"
- maxWait="10000"
- initialSize="10"
- removeAbandonedTimeout="60"
- removeAbandoned="true"
- logAbandoned="true"
- minEvictableIdleTimeMillis="30000"
- jmxEnabled="true"
- jdbcInterceptors="org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;
- org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer"
- username="root"
- password="password"
- driverClassName="com.mysql.jdbc.Driver"
- url="jdbc:mysql://localhost:3306/mysql"/>]]></source>
-
- </subsection>
- <subsection name="Asynchronous Connection Retrieval">
- <p> The Tomcat JDBC connection pool supports asynchronous connection retrieval without adding additional threads to the
- pool library. It does this by adding a method to the data source called <code>Future<Connection> getConnectionAsync()</code>.
- In order to use the async retrieval, two conditions must be met:
- </p>
- <ol>
- <li>You must configure the <code>fairQueue</code> property to be <code>true</code>.</li>
- <li>You will have to cast the data source to <code>org.apache.tomcat.jdbc.pool.DataSource</code></li>
- </ol>
- An example of using the async feature is show below.
-<source><![CDATA[ Connection con = null;
- try {
- Future<Connection> future = datasource.getConnectionAsync();
- while (!future.isDone()) {
- System.out.println("Connection is not yet available. Do some background work");
- try {
- Thread.sleep(100); //simulate work
- }catch (InterruptedException x) {
- Thread.currentThread().interrupt();
- }
- }
- con = future.get(); //should return instantly
- Statement st = con.createStatement();
- ResultSet rs = st.executeQuery("select * from user");]]></source>
-
- </subsection>
- <subsection name="Interceptors">
- <p>Interceptors are a powerful way to enable, disable or modify functionality on a specific connection or its sub components.
- There are many different use cases for when interceptors are useful. By default, and for performance reasons, the connection pool is stateless.
- The only state the pool itself inserts are <code>defaultAutoCommit</code>, <code>defaultReadOnly</code>, <code>defaultTransactionIsolation</code>, <code>defaultCatalog</code> if
- these are set. These 4 properties are only set upon connection creation. Should these properties be modified during the usage of the connection,
- the pool itself will not reset them.</p>
- <p>An interceptor has to extend the <code>org.apache.tomcat.jdbc.pool.JdbcInterceptor</code> class. This class is fairly simple,
- You will need to have a no arg constructor</p>
-<source><![CDATA[ public JdbcInterceptor() {
- }]]></source>
- <p>
- When a connection is borrowed from the pool, the interceptor can initialize or in some other way react to the event by implementing the
- </p>
-<source><![CDATA[ public abstract void reset(ConnectionPool parent, PooledConnection con);]]></source>
- <p>
- method. This method gets called with two parameters, a reference to the connection pool itself <code>ConnectionPool parent</code>
- and a reference to the underlying connection <code>PooledConnection con</code>.
- </p>
- <p>
- When a method on the <code>java.sql.Connection</code> object is invoked, it will cause the
- </p>
-<source><![CDATA[ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable]]></source>
- <p>
- method to get invoked. The <code>Method method</code> is the actual method invoked, and <code>Object[] args</code> are the arguments.
- To look at a very simple example, where we demonstrate how to make the invokation to <code>java.sql.Connection.close()</code> a noop
- if the connection has been closed
- </p>
-<source><![CDATA[ if (CLOSE_VAL==method.getName()) {
- if (isClosed()) return null; //noop for already closed.
- }
- return super.invoke(proxy,method,args);]]></source>
- <p>
- There is an observation being made. It is the comparison of the method name. One way to do this would be to do
- <code>"close".equals(method.getName())</code>.
- Above we see a direct reference comparison between the method name and <code>static final String</code> reference.
- According to the JVM spec, method names and static final String end up in a shared constant pool, so the reference comparison should work.
- One could of course do this as well:
- </p>
-<source><![CDATA[ if (compare(CLOSE_VAL,method)) {
- if (isClosed()) return null; //noop for already closed.
- }
- return super.invoke(proxy,method,args);]]></source>
- <p>
- The <code>compare(String,Method)</code> will use the <code>useEquals</code> flag on an interceptor and do either reference comparison or
- a string value comparison when the <code>useEquals=true</code> flag is set.
- </p>
- <p>Pool start/stop<br/>
- When the connection pool is started or closed, you can be notifed. You will only be notified once per interceptor class
- even though it is an instance method. and you will be notified using an interceptor currently not attached to a pool.
- </p>
-<source><![CDATA[ public void poolStarted(ConnectionPool pool) {
- }
-
- public void poolClosed(ConnectionPool pool) {
- }]]></source>
- <p>
- When overriding these methods, don't forget to call super if you are extending a class other than <code>JdbcInterceptor</code>
- </p>
- <p>Configuring interceptors<br/>
- Interceptors are configured using the <code>jdbcInterceptors</code> property or the <code>setJdbcInterceptors</code> method.
- An interceptor can have properties, and would be configured like this
- </p>
-<source><![CDATA[ String jdbcInterceptors=
- "org.apache.tomcat.jdbc.pool.interceptor.ConnectionState(useEquals=true,fast=yes)"]]></source>
-
- <p>Interceptor properties<br/>
- Since interceptors can have properties, you need to be able to read the values of these properties within your
- interceptor. Taking an example like the one above, you can override the <code>setProperties</code> method.
- </p>
-<source><![CDATA[ public void setProperties(Map<String, InterceptorProperty> properties) {
- super.setProperties(properties);
- final String myprop = "myprop";
- InterceptorProperty p1 = properties.get(myprop);
- if (p1!=null) {
- setMyprop(Long.parseLong(p1.getValue()));
- }
- }]]></source>
-
- </subsection>
- <subsection name="Getting the actual JDBC connection">
- <p>Connection pools create wrappers around the actual connection in order to properly pool them.
- We also create interceptors in these wrappers to be able to perform certain functions.
- If there is a need to retrieve the actual connection, one can do so using the <code>javax.sql.PooledConnection</code>
- interface.
- </p>
-<source><![CDATA[ Connection con = datasource.getConnection();
- Connection actual = ((javax.sql.PooledConnection)con).getConnection();]]></source>
-
- </subsection>
-
-</section>
-
-<section name="Building">
- <p>We build the JDBC pool code with 1.6, but it is backwards compatible down to 1.5 for runtime environment. For unit test, we use 1.6 and higher</p>
- <p>Other examples of Tomcat configuration for JDBC usage can be found <a href="http://tomcat.apache.org/tomcat-8.0-doc/jndi-datasource-examples-howto.html">in the Tomcat documentation</a>. </p>
- <subsection name="Building from source">
- <p>Building is pretty simple. The pool has a dependency on <code>tomcat-juli.jar</code> and in case you want the <code>SlowQueryReportJmx</code></p>
-<source><![CDATA[ javac -classpath tomcat-juli.jar \
- -d . \
- org/apache/tomcat/jdbc/pool/*.java \
- org/apache/tomcat/jdbc/pool/interceptor/*.java \
- org/apache/tomcat/jdbc/pool/jmx/*.java]]></source>
- <p>
- A build file can be found in the Tomcat <a href="http://svn.apache.org/viewvc/tomcat/trunk/modules/jdbc-pool/">source repository</a>.
- </p>
- <p>
- As a convenience, a build file is also included where a simple build command will generate all files needed.
- </p>
-<source> ant download (downloads dependencies)
- ant build (compiles and generates .jar files)
- ant dist (creates a release package)
- ant test (runs tests, expects a test database to be setup)</source>
-
- <p>
- The system is structured for a Maven build, but does generate release artifacts. Just the library itself.
- </p>
- </subsection>
-</section>
-</body>
-
-</document>
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements. See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<!--
- Stylesheet that generates "package.html" for Javadoc tool
- from jdbc-pool.xml documentation file.
- It is based on "tomcat-docs" stylesheet, but it needs to avoid
- generating complicated headers and footers, as those cannot be
- digested by Javadoc tool and break layout of javadoc pages.
--->
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
- version="1.0">
-
-
- <!-- Output method -->
- <xsl:output method="html"
- encoding="UTF-8"
- indent="no"/>
-
-
- <!-- Defined parameters (overrideable) -->
- <xsl:param name="relative-path" select="'.'"/>
- <xsl:param name="void-image" select="'/images/void.gif'"/>
- <xsl:param name="standalone" select="''"/>
- <xsl:param name="buglink" select="'http://bz.apache.org/bugzilla/show_bug.cgi?id='"/>
- <xsl:param name="revlink" select="'http://svn.apache.org/viewvc?view=rev&rev='"/>
-
- <!-- Defined variables (non-overrideable) -->
- <xsl:variable name="body-bg" select="'#ffffff'"/>
- <xsl:variable name="body-fg" select="'#000000'"/>
- <xsl:variable name="body-link" select="'#525D76'"/>
- <xsl:variable name="banner-bg" select="'#525D76'"/>
- <xsl:variable name="banner-fg" select="'#ffffff'"/>
- <xsl:variable name="sub-banner-bg" select="'#828DA6'"/>
- <xsl:variable name="sub-banner-fg" select="'#ffffff'"/>
- <xsl:variable name="source-color" select="'#023264'"/>
- <xsl:variable name="attributes-color" select="'#023264'"/>
- <xsl:variable name="table-th-bg" select="'#039acc'"/>
- <xsl:variable name="table-td-bg" select="'#a0ddf0'"/>
-
- <!-- Process an entire document into an HTML page -->
- <xsl:template match="document">
- <xsl:variable name="project"
- select="document('project.xml')/project"/>
- <html>
- <head>
- <title><xsl:value-of select="project/title"/> - <xsl:value-of select="properties/title"/></title>
- </head>
-
- <body bgcolor="{$body-bg}" text="{$body-fg}" link="{$body-link}"
- alink="{$body-link}" vlink="{$body-link}">
-
- <h2><xsl:value-of select="properties/title"/>.</h2>
- <xsl:apply-templates select="body/section"/>
- </body>
- </html>
-
- </xsl:template>
-
-
- <!-- Process a documentation section -->
- <xsl:template match="section">
- <xsl:variable name="name">
- <xsl:value-of select="@name"/>
- </xsl:variable>
- <table border="0" cellspacing="0" cellpadding="2">
- <!-- Section heading -->
- <tr><td bgcolor="{$banner-bg}">
- <font color="{$banner-fg}" face="arial,helvetica.sanserif">
- <a name="{$name}">
- <strong><xsl:value-of select="@name"/></strong></a></font>
- </td></tr>
- <!-- Section body -->
- <tr><td><blockquote>
- <xsl:apply-templates/>
- </blockquote></td></tr>
- </table>
- </xsl:template>
-
-
- <!-- Process a documentation subsection -->
- <xsl:template match="subsection">
- <xsl:variable name="name">
- <xsl:value-of select="@name"/>
- </xsl:variable>
- <table border="0" cellspacing="0" cellpadding="2">
- <!-- Subsection heading -->
- <tr><td bgcolor="{$sub-banner-bg}">
- <font color="{$sub-banner-fg}" face="arial,helvetica.sanserif">
- <a name="{$name}">
- <strong><xsl:value-of select="@name"/></strong></a></font>
- </td></tr>
- <!-- Subsection body -->
- <tr><td><blockquote>
- <xsl:apply-templates/>
- </blockquote></td></tr>
- </table>
- </xsl:template>
-
-
- <!-- Process a source code example -->
- <xsl:template match="source">
- <xsl:variable name="void">
- <xsl:value-of select="$relative-path"/><xsl:value-of select="$void-image"/>
- </xsl:variable>
- <div align="left">
- <table cellspacing="4" cellpadding="0" border="0">
- <tr>
- <td bgcolor="{$source-color}" width="1" height="1">
- <img src="{$void}" width="1" height="1" vspace="0" hspace="0" border="0"/>
- </td>
- <td bgcolor="{$source-color}" height="1">
- <img src="{$void}" width="1" height="1" vspace="0" hspace="0" border="0"/>
- </td>
- <td bgcolor="{$source-color}" width="1" height="1">
- <img src="{$void}" width="1" height="1" vspace="0" hspace="0" border="0"/>
- </td>
- </tr>
- <tr>
- <td bgcolor="{$source-color}" width="1">
- <img src="{$void}" width="1" height="1" vspace="0" hspace="0" border="0"/>
- </td>
- <td bgcolor="#ffffff" height="1"><pre>
- <xsl:value-of select="."/>
- </pre></td>
- <td bgcolor="{$source-color}" width="1">
- <img src="{$void}" width="1" height="1" vspace="0" hspace="0" border="0"/>
- </td>
- </tr>
- <tr>
- <td bgcolor="{$source-color}" width="1" height="1">
- <img src="{$void}" width="1" height="1" vspace="0" hspace="0" border="0"/>
- </td>
- <td bgcolor="{$source-color}" height="1">
- <img src="{$void}" width="1" height="1" vspace="0" hspace="0" border="0"/>
- </td>
- <td bgcolor="{$source-color}" width="1" height="1">
- <img src="{$void}" width="1" height="1" vspace="0" hspace="0" border="0"/>
- </td>
- </tr>
- </table>
- </div>
- </xsl:template>
-
-
- <!-- Process an attributes list with nested attribute elements -->
- <xsl:template match="attributes">
- <table border="1" cellpadding="5">
- <tr>
- <th width="15%" bgcolor="{$attributes-color}">
- <font color="#ffffff">Attribute</font>
- </th>
- <th width="85%" bgcolor="{$attributes-color}">
- <font color="#ffffff">Description</font>
- </th>
- </tr>
- <xsl:for-each select="attribute">
- <tr>
- <td align="left" valign="center">
- <xsl:if test="@required = 'true'">
- <strong><code><xsl:value-of select="@name"/></code></strong>
- </xsl:if>
- <xsl:if test="@required != 'true'">
- <code><xsl:value-of select="@name"/></code>
- </xsl:if>
- </td>
- <td align="left" valign="center">
- <xsl:apply-templates/>
- </td>
- </tr>
- </xsl:for-each>
- </table>
- </xsl:template>
-
- <!-- Process a properties list with nested property elements -->
- <xsl:template match="properties">
- <table border="1" cellpadding="5">
- <tr>
- <th width="15%" bgcolor="{$attributes-color}">
- <font color="#ffffff">Property</font>
- </th>
- <th width="85%" bgcolor="{$attributes-color}">
- <font color="#ffffff">Description</font>
- </th>
- </tr>
- <xsl:for-each select="property">
- <tr>
- <td align="left" valign="center">
- <code><xsl:value-of select="@name"/></code>
- </td>
- <td align="left" valign="center">
- <xsl:apply-templates/>
- </td>
- </tr>
- </xsl:for-each>
- </table>
- </xsl:template>
-
- <!-- Fix relative links in printer friendly versions of the docs -->
- <xsl:template match="a">
- <xsl:variable name="href" select="@href"/>
- <xsl:choose>
- <xsl:when test="$standalone = 'standalone'">
- <xsl:apply-templates/>
- </xsl:when>
- <xsl:when test="$href != ''">
- <a href="{$href}"><xsl:apply-templates/></a>
- </xsl:when>
- <xsl:otherwise>
- <xsl:variable name="name" select="@name"/>
- <a name="{$name}"><xsl:apply-templates/></a>
- </xsl:otherwise>
- </xsl:choose>
- </xsl:template>
-
- <!-- Link to a bug report -->
- <xsl:template match="bug">
- <xsl:variable name="link"><xsl:value-of select="$buglink"/><xsl:value-of select="text()"/></xsl:variable>
- <a href="{$link}"><xsl:apply-templates/></a>
- </xsl:template>
-
- <!-- Link to a SVN revision report -->
- <xsl:template match="rev">
- <xsl:variable name="link"><xsl:value-of select="$revlink"/><xsl:value-of select="text()"/></xsl:variable>
- <a href="{$link}"><xsl:apply-templates/></a>
- </xsl:template>
-
- <!-- Process everything else by just passing it through -->
- <xsl:template match="*|@*">
- <xsl:copy>
- <xsl:apply-templates select="@*|*|text()"/>
- </xsl:copy>
- </xsl:template>
-
-</xsl:stylesheet>
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements. See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<project name="Apache Tomcat JDBC Pool Documentation"
- href="http://tomcat.apache.org/">
-
- <title>Apache Tomcat JDBC Pool</title>
-
- <logo href="/images/tomcat.gif">
- The Apache Tomcat Servlet/JSP Container
- </logo>
-
- <body>
- </body>
-
-</project>
-
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <parent>
- <groupId>org.openecomp.sdnc.core</groupId>
- <artifactId>dblib</artifactId>
- <version>1.1.1-SNAPSHOT</version>
- </parent>
- <artifactId>dblib-common</artifactId>
- <packaging>bundle</packaging>
- <name>DBLIB Adaptor - Common</name>
- <properties>
- <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
- </properties>
-
- <dependencies>
- <dependency>
- <groupId>org.apache.tomcat</groupId>
- <artifactId>juli</artifactId>
- <version>6.0.32</version>
- </dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <version>4.11</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.apache.tomcat</groupId>
- <artifactId>tomcat-dbcp</artifactId>
- <version>8.0.14</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>com.h2database</groupId>
- <artifactId>h2</artifactId>
- <version>1.3.152</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>equinoxSDK381</groupId>
- <artifactId>org.eclipse.osgi</artifactId>
- <version>${equinox.osgi.version}</version>
- </dependency>
- <dependency>
- <groupId>mysql</groupId>
- <artifactId>mysql-connector-java</artifactId>
- <version>${mysql.connector.version}</version>
- </dependency>
-
- </dependencies>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-compiler-plugin</artifactId>
- <configuration>
- <source>1.7</source>
- <target>1.7</target>
- </configuration>
- </plugin>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Bundle-Activator>org.openecomp.sdnc.sli.resource.common.CommonActivator</Bundle-Activator>
- <Export-Package>
- org.openecomp.sdnc.sli.resource.common;version=${project.version},
- org.apache.tomcat.jdbc;version=${project.version},
- org.apache.tomcat.jdbc.pool;version=${project.version},
- org.apache.tomcat.jdbc.naming;version=${project.version},
- org.apache.tomcat.jdbc.pool.interceptor;version=${project.version},
- org.apache.tomcat.jdbc.pool.jmx;version=${project.version}</Export-Package>
- <Import-Package>*</Import-Package>
- <!--
- <Embed-Dependency>*;scope=compile;artifactId=commons-lang|commons-lang3</Embed-Dependency>
- -->
- <Embed-Transitive>true</Embed-Transitive>
- </instructions>
- <manifestLocation>${project.basedir}/src/main/resources/META-INF</manifestLocation>
- </configuration>
- </plugin>
- </plugins>
- </build>
-</project>
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.naming;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.util.Enumeration;
-import java.util.Hashtable;
-
-import javax.naming.Context;
-import javax.naming.Name;
-import javax.naming.RefAddr;
-import javax.naming.Reference;
-import javax.naming.spi.ObjectFactory;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.ClassLoaderUtil;
-
-/**
- * Simple way of configuring generic resources by using reflection.
- * Example usage:
- * <pre><code>
- * <Resource factory="org.apache.tomcat.jdbc.naming.GenericNamingResourcesFactory"
- * name="jdbc/test"
- * type="org.apache.derby.jdbc.ClientXADataSource"
- * databaseName="sample"
- * createDatabase="create"
- * serverName="localhost"
- * port="1527"/>
- * </code></pre>
- *
- */
-public class GenericNamingResourcesFactory implements ObjectFactory {
- private static final Log log = LogFactory.getLog(GenericNamingResourcesFactory.class);
-
- @Override
- public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
- if ((obj == null) || !(obj instanceof Reference)) {
- return null;
- }
- Reference ref = (Reference) obj;
- Enumeration<RefAddr> refs = ref.getAll();
-
- String type = ref.getClassName();
- Object o =
- ClassLoaderUtil.loadClass(
- type,
- GenericNamingResourcesFactory.class.getClassLoader(),
- Thread.currentThread().getContextClassLoader())
- .newInstance();
-
- while (refs.hasMoreElements()) {
- RefAddr addr = refs.nextElement();
- String param = addr.getType();
- String value = null;
- if (addr.getContent()!=null) {
- value = addr.getContent().toString();
- }
- if (setProperty(o, param, value)) {
-
- } else {
- log.debug("Property not configured["+param+"]. No setter found on["+o+"].");
- }
- }
- return o;
- }
-
- @SuppressWarnings("null") // setPropertyMethodVoid can't be null when used
- private static boolean setProperty(Object o, String name, String value) {
- if (log.isDebugEnabled())
- log.debug("IntrospectionUtils: setProperty(" +
- o.getClass() + " " + name + "=" + value + ")");
-
- String setter = "set" + capitalize(name);
-
- try {
- Method methods[] = o.getClass().getMethods();
- Method setPropertyMethodVoid = null;
- Method setPropertyMethodBool = null;
-
- // First, the ideal case - a setFoo( String ) method
- for (int i = 0; i < methods.length; i++) {
- Class<?> paramT[] = methods[i].getParameterTypes();
- if (setter.equals(methods[i].getName()) && paramT.length == 1
- && "java.lang.String".equals(paramT[0].getName())) {
-
- methods[i].invoke(o, new Object[] { value });
- return true;
- }
- }
-
- // Try a setFoo ( int ) or ( boolean )
- for (int i = 0; i < methods.length; i++) {
- boolean ok = true;
- if (setter.equals(methods[i].getName())
- && methods[i].getParameterTypes().length == 1) {
-
- // match - find the type and invoke it
- Class<?> paramType = methods[i].getParameterTypes()[0];
- Object params[] = new Object[1];
-
- // Try a setFoo ( int )
- if ("java.lang.Integer".equals(paramType.getName())
- || "int".equals(paramType.getName())) {
- try {
- params[0] = new Integer(value);
- } catch (NumberFormatException ex) {
- ok = false;
- }
- // Try a setFoo ( long )
- }else if ("java.lang.Long".equals(paramType.getName())
- || "long".equals(paramType.getName())) {
- try {
- params[0] = new Long(value);
- } catch (NumberFormatException ex) {
- ok = false;
- }
-
- // Try a setFoo ( boolean )
- } else if ("java.lang.Boolean".equals(paramType.getName())
- || "boolean".equals(paramType.getName())) {
- params[0] = Boolean.valueOf(value);
-
- // Try a setFoo ( InetAddress )
- } else if ("java.net.InetAddress".equals(paramType
- .getName())) {
- try {
- params[0] = InetAddress.getByName(value);
- } catch (UnknownHostException exc) {
- if (log.isDebugEnabled())
- log.debug("IntrospectionUtils: Unable to resolve host name:" + value);
- ok = false;
- }
-
- // Unknown type
- } else {
- if (log.isDebugEnabled())
- log.debug("IntrospectionUtils: Unknown type " +
- paramType.getName());
- }
-
- if (ok) {
- methods[i].invoke(o, params);
- return true;
- }
- }
-
- // save "setProperty" for later
- if ("setProperty".equals(methods[i].getName())) {
- if (methods[i].getReturnType()==Boolean.TYPE){
- setPropertyMethodBool = methods[i];
- }else {
- setPropertyMethodVoid = methods[i];
- }
-
- }
- }
-
- // Ok, no setXXX found, try a setProperty("name", "value")
- if (setPropertyMethodBool != null || setPropertyMethodVoid != null) {
- Object params[] = new Object[2];
- params[0] = name;
- params[1] = value;
- if (setPropertyMethodBool != null) {
- try {
- return ((Boolean) setPropertyMethodBool.invoke(o, params)).booleanValue();
- }catch (IllegalArgumentException biae) {
- //the boolean method had the wrong
- //parameter types. lets try the other
- if (setPropertyMethodVoid!=null) {
- setPropertyMethodVoid.invoke(o, params);
- return true;
- }else {
- throw biae;
- }
- }
- } else {
- setPropertyMethodVoid.invoke(o, params);
- return true;
- }
- }
-
- } catch (IllegalArgumentException ex2) {
- log.warn("IAE " + o + " " + name + " " + value, ex2);
- } catch (SecurityException ex1) {
- if (log.isDebugEnabled())
- log.debug("IntrospectionUtils: SecurityException for " +
- o.getClass() + " " + name + "=" + value + ")", ex1);
- } catch (IllegalAccessException iae) {
- if (log.isDebugEnabled())
- log.debug("IntrospectionUtils: IllegalAccessException for " +
- o.getClass() + " " + name + "=" + value + ")", iae);
- } catch (InvocationTargetException ie) {
- Throwable cause = ie.getCause();
- if (cause instanceof ThreadDeath) {
- throw (ThreadDeath) cause;
- }
- if (cause instanceof VirtualMachineError) {
- throw (VirtualMachineError) cause;
- }
- if (log.isDebugEnabled())
- log.debug("IntrospectionUtils: InvocationTargetException for " +
- o.getClass() + " " + name + "=" + value + ")", ie);
- }
- return false;
- }
-
- public static String capitalize(String name) {
- if (name == null || name.length() == 0) {
- return name;
- }
- char chars[] = name.toCharArray();
- chars[0] = Character.toUpperCase(chars[0]);
- return new String(chars);
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-
-public class ClassLoaderUtil {
- private static final Log log = LogFactory.getLog(ClassLoaderUtil.class);
-
- private static final boolean onlyAttemptFirstLoader =
- Boolean.parseBoolean(System.getProperty("org.apache.tomcat.jdbc.pool.onlyAttemptCurrentClassLoader", "false"));
-
- public static Class<?> loadClass(String className, ClassLoader... classLoaders) throws ClassNotFoundException {
- ClassNotFoundException last = null;
- StringBuilder errorMsg = null;
- for (ClassLoader cl : classLoaders) {
- try {
- if (cl!=null) {
- if (log.isDebugEnabled()) {
- log.debug("Attempting to load class["+className+"] from "+cl);
- }
- return Class.forName(className, true, cl);
- } else {
- throw new ClassNotFoundException("Classloader is null");
- }
- } catch (ClassNotFoundException x) {
- last = x;
- if (errorMsg==null) {
- errorMsg = new StringBuilder();
- } else {
- errorMsg.append(';');
- }
- errorMsg.append("ClassLoader:");
- errorMsg.append(cl);
- }
- if (onlyAttemptFirstLoader) {
- break;
- }
- }
- throw new ClassNotFoundException("Unable to load class: "+className+" from "+errorMsg, last);
- }
-
-
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.lang.ref.WeakReference;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Proxy;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.util.Collections;
-import java.util.ConcurrentModificationException;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-import java.util.Timer;
-import java.util.TimerTask;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-
-/**
- * Implementation of simple connection pool.
- * The ConnectionPool uses a {@link PoolProperties} object for storing all the meta information about the connection pool.
- * As the underlying implementation, the connection pool uses {@link java.util.concurrent.BlockingQueue} to store active and idle connections.
- * A custom implementation of a fair {@link FairBlockingQueue} blocking queue is provided with the connection pool itself.
- * @version 1.0
- */
-public class ConnectionPool {
-
- /**
- * Default domain for objects registering with an mbean server
- */
- public static final String POOL_JMX_DOMAIN = "tomcat.jdbc";
- /**
- * Prefix type for JMX registration
- */
- public static final String POOL_JMX_TYPE_PREFIX = POOL_JMX_DOMAIN+":type=";
-
- /**
- * Logger
- */
- private static final Log log = LogFactory.getLog(ConnectionPool.class);
-
- //===============================================================================
- // INSTANCE/QUICK ACCESS VARIABLE
- //===============================================================================
- /**
- * Carries the size of the pool, instead of relying on a queue implementation
- * that usually iterates over to get an exact count
- */
- private AtomicInteger size = new AtomicInteger(0);
-
- /**
- * All the information about the connection pool
- * These are the properties the pool got instantiated with
- */
- private PoolConfiguration poolProperties;
-
- /**
- * Contains all the connections that are in use
- * TODO - this shouldn't be a blocking queue, simply a list to hold our objects
- */
- private BlockingQueue<PooledConnection> busy;
-
- /**
- * Contains all the idle connections
- */
- private BlockingQueue<PooledConnection> idle;
-
- /**
- * The thread that is responsible for checking abandoned and idle threads
- */
- private volatile PoolCleaner poolCleaner;
-
- /**
- * Pool closed flag
- */
- private volatile boolean closed = false;
-
- /**
- * Since newProxyInstance performs the same operation, over and over
- * again, it is much more optimized if we simply store the constructor ourselves.
- */
- private Constructor<?> proxyClassConstructor;
-
- /**
- * Executor service used to cancel Futures
- */
- private ThreadPoolExecutor cancellator = new ThreadPoolExecutor(0,1,1000,TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
-
- /**
- * reference to the JMX mbean
- */
- protected org.apache.tomcat.jdbc.pool.jmx.ConnectionPool jmxPool = null;
-
- /**
- * counter to track how many threads are waiting for a connection
- */
- private AtomicInteger waitcount = new AtomicInteger(0);
-
- private AtomicLong poolVersion = new AtomicLong(Long.MIN_VALUE);
-
- /**
- * The counters for statistics of the pool.
- */
- private final AtomicLong borrowedCount = new AtomicLong(0);
- private final AtomicLong returnedCount = new AtomicLong(0);
- private final AtomicLong createdCount = new AtomicLong(0);
- private final AtomicLong releasedCount = new AtomicLong(0);
- private final AtomicLong reconnectedCount = new AtomicLong(0);
- private final AtomicLong removeAbandonedCount = new AtomicLong(0);
- private final AtomicLong releasedIdleCount = new AtomicLong(0);
-
- //===============================================================================
- // PUBLIC METHODS
- //===============================================================================
-
- /**
- * Instantiate a connection pool. This will create connections if initialSize is larger than 0.
- * The {@link PoolProperties} should not be reused for another connection pool.
- * @param prop PoolProperties - all the properties for this connection pool
- * @throws SQLException Pool initialization error
- */
- public ConnectionPool(PoolConfiguration prop) throws SQLException {
- //setup quick access variables and pools
- init(prop);
- }
-
-
- /**
- * Retrieves a Connection future. If a connection is not available, one can block using future.get()
- * until a connection has become available.
- * If a connection is not retrieved, the Future must be cancelled in order for the connection to be returned
- * to the pool.
- * @return a Future containing a reference to the connection or the future connection
- * @throws SQLException Cannot use asynchronous connect
- */
- public Future<Connection> getConnectionAsync() throws SQLException {
- try {
- PooledConnection pc = borrowConnection(0, null, null);
- if (pc!=null) {
- return new ConnectionFuture(pc);
- }
- }catch (SQLException x) {
- if (x.getMessage().indexOf("NoWait")<0) {
- throw x;
- }
- }
- //we can only retrieve a future if the underlying queue supports it.
- if (idle instanceof FairBlockingQueue<?>) {
- Future<PooledConnection> pcf = ((FairBlockingQueue<PooledConnection>)idle).pollAsync();
- return new ConnectionFuture(pcf);
- } else if (idle instanceof MultiLockFairBlockingQueue<?>) {
- Future<PooledConnection> pcf = ((MultiLockFairBlockingQueue<PooledConnection>)idle).pollAsync();
- return new ConnectionFuture(pcf);
- } else {
- throw new SQLException("Connection pool is misconfigured, doesn't support async retrieval. Set the 'fair' property to 'true'");
- }
- }
-
- /**
- * Borrows a connection from the pool. If a connection is available (in the idle queue) or the pool has not reached
- * {@link PoolProperties#maxActive maxActive} connections a connection is returned immediately.
- * If no connection is available, the pool will attempt to fetch a connection for {@link PoolProperties#maxWait maxWait} milliseconds.
- * @return Connection - a java.sql.Connection/javax.sql.PooledConnection reflection proxy, wrapping the underlying object.
- * @throws SQLException - if the wait times out or a failure occurs creating a connection
- */
- public Connection getConnection() throws SQLException {
- //check out a connection
- PooledConnection con = borrowConnection(-1,null,null);
- return setupConnection(con);
- }
-
-
- /**
- * Borrows a connection from the pool. If a connection is available (in the
- * idle queue) or the pool has not reached {@link PoolProperties#maxActive
- * maxActive} connections a connection is returned immediately. If no
- * connection is available, the pool will attempt to fetch a connection for
- * {@link PoolProperties#maxWait maxWait} milliseconds.
- * @param username The user name to use for the connection
- * @param password The password for the connection
- * @return Connection - a java.sql.Connection/javax.sql.PooledConnection
- * reflection proxy, wrapping the underlying object.
- * @throws SQLException
- * - if the wait times out or a failure occurs creating a
- * connection
- */
- public Connection getConnection(String username, String password) throws SQLException {
- // check out a connection
- PooledConnection con = borrowConnection(-1, username, password);
- return setupConnection(con);
- }
-
- /**
- * Returns the name of this pool
- * @return String - the name of the pool
- */
- public String getName() {
- return getPoolProperties().getPoolName();
- }
-
- /**
- * Return the number of threads waiting for a connection
- * @return number of threads waiting for a connection
- */
- public int getWaitCount() {
- return waitcount.get();
- }
-
- /**
- * Returns the pool properties associated with this connection pool
- * @return PoolProperties
- *
- */
- public PoolConfiguration getPoolProperties() {
- return this.poolProperties;
- }
-
- /**
- * Returns the total size of this pool, this includes both busy and idle connections
- * @return int - number of established connections to the database
- */
- public int getSize() {
- return size.get();
- }
-
- /**
- * Returns the number of connections that are in use
- * @return int - number of established connections that are being used by the application
- */
- public int getActive() {
- return busy.size();
- }
-
- /**
- * Returns the number of idle connections
- * @return int - number of established connections not being used
- */
- public int getIdle() {
- return idle.size();
- }
-
- /**
- * Returns true if {@link #close close} has been called, and the connection pool is unusable
- * @return boolean
- */
- public boolean isClosed() {
- return this.closed;
- }
-
- //===============================================================================
- // PROTECTED METHODS
- //===============================================================================
-
-
- /**
- * configures a pooled connection as a proxy.
- * This Proxy implements {@link java.sql.Connection} and {@link javax.sql.PooledConnection} interfaces.
- * All calls on {@link java.sql.Connection} methods will be propagated down to the actual JDBC connection except for the
- * {@link java.sql.Connection#close()} method.
- * @param con a {@link PooledConnection} to wrap in a Proxy
- * @return a {@link java.sql.Connection} object wrapping a pooled connection.
- * @throws SQLException if an interceptor can't be configured, if the proxy can't be instantiated
- */
- protected Connection setupConnection(PooledConnection con) throws SQLException {
- //fetch previously cached interceptor proxy - one per connection
- JdbcInterceptor handler = con.getHandler();
- if (handler==null) {
- //build the proxy handler
- handler = new ProxyConnection(this,con,getPoolProperties().isUseEquals());
- //set up the interceptor chain
- PoolProperties.InterceptorDefinition[] proxies = getPoolProperties().getJdbcInterceptorsAsArray();
- for (int i=proxies.length-1; i>=0; i--) {
- try {
- //create a new instance
- JdbcInterceptor interceptor = proxies[i].getInterceptorClass().newInstance();
- //configure properties
- interceptor.setProperties(proxies[i].getProperties());
- //setup the chain
- interceptor.setNext(handler);
- //call reset
- interceptor.reset(this, con);
- //configure the last one to be held by the connection
- handler = interceptor;
- }catch(Exception x) {
- SQLException sx = new SQLException("Unable to instantiate interceptor chain.");
- sx.initCause(x);
- throw sx;
- }
- }
- //cache handler for the next iteration
- con.setHandler(handler);
- } else {
- JdbcInterceptor next = handler;
- //we have a cached handler, reset it
- while (next!=null) {
- next.reset(this, con);
- next = next.getNext();
- }
- }
-
- try {
- getProxyConstructor(con.getXAConnection() != null);
- //create the proxy
- //TODO possible optimization, keep track if this connection was returned properly, and don't generate a new facade
- Connection connection = null;
- if (getPoolProperties().getUseDisposableConnectionFacade() ) {
- connection = (Connection)proxyClassConstructor.newInstance(new Object[] { new DisposableConnectionFacade(handler) });
- } else {
- connection = (Connection)proxyClassConstructor.newInstance(new Object[] {handler});
- }
- //return the connection
- return connection;
- }catch (Exception x) {
- SQLException s = new SQLException();
- s.initCause(x);
- throw s;
- }
-
- }
-
- /**
- * Creates and caches a {@link java.lang.reflect.Constructor} used to instantiate the proxy object.
- * We cache this, since the creation of a constructor is fairly slow.
- * @param xa Use a XA connection
- * @return constructor used to instantiate the wrapper object
- * @throws NoSuchMethodException Failed to get a constructor
- */
- public Constructor<?> getProxyConstructor(boolean xa) throws NoSuchMethodException {
- //cache the constructor
- if (proxyClassConstructor == null ) {
- Class<?> proxyClass = xa ?
- Proxy.getProxyClass(ConnectionPool.class.getClassLoader(), new Class[] {java.sql.Connection.class,javax.sql.PooledConnection.class, javax.sql.XAConnection.class}) :
- Proxy.getProxyClass(ConnectionPool.class.getClassLoader(), new Class[] {java.sql.Connection.class,javax.sql.PooledConnection.class});
- proxyClassConstructor = proxyClass.getConstructor(new Class[] { InvocationHandler.class });
- }
- return proxyClassConstructor;
- }
-
- /**
- * Closes the pool and all disconnects all idle connections
- * Active connections will be closed upon the {@link java.sql.Connection#close close} method is called
- * on the underlying connection instead of being returned to the pool
- * @param force - true to even close the active connections
- */
- protected void close(boolean force) {
- //are we already closed
- if (this.closed) return;
- //prevent other threads from entering
- this.closed = true;
- //stop background thread
- if (poolCleaner!=null) {
- poolCleaner.stopRunning();
- }
-
- /* release all idle connections */
- BlockingQueue<PooledConnection> pool = (idle.size()>0)?idle:(force?busy:idle);
- while (pool.size()>0) {
- try {
- //retrieve the next connection
- PooledConnection con = pool.poll(1000, TimeUnit.MILLISECONDS);
- //close it and retrieve the next one, if one is available
- while (con != null) {
- //close the connection
- if (pool==idle)
- release(con);
- else
- abandon(con);
- if (pool.size()>0) {
- con = pool.poll(1000, TimeUnit.MILLISECONDS);
- } else {
- break;
- }
- } //while
- } catch (InterruptedException ex) {
- if (getPoolProperties().getPropagateInterruptState()) {
- Thread.currentThread().interrupt();
- }
- }
- if (pool.size()==0 && force && pool!=busy) pool = busy;
- }
- if (this.getPoolProperties().isJmxEnabled()) this.jmxPool = null;
- PoolProperties.InterceptorDefinition[] proxies = getPoolProperties().getJdbcInterceptorsAsArray();
- for (int i=0; i<proxies.length; i++) {
- try {
- JdbcInterceptor interceptor = proxies[i].getInterceptorClass().newInstance();
- interceptor.setProperties(proxies[i].getProperties());
- interceptor.poolClosed(this);
- }catch (Exception x) {
- log.debug("Unable to inform interceptor of pool closure.",x);
- }
- }
- } //closePool
-
-
- /**
- * Initialize the connection pool - called from the constructor
- * @param properties PoolProperties - properties used to initialize the pool with
- * @throws SQLException if initialization fails
- */
- protected void init(PoolConfiguration properties) throws SQLException {
- poolProperties = properties;
-
- //make sure the pool is properly configured
- checkPoolConfiguration(properties);
-
- //make space for 10 extra in case we flow over a bit
- busy = new LinkedBlockingQueue<>();
- //busy = new FairBlockingQueue<PooledConnection>();
- //make space for 10 extra in case we flow over a bit
- if (properties.isFairQueue()) {
- idle = new FairBlockingQueue<>();
- //idle = new MultiLockFairBlockingQueue<PooledConnection>();
- //idle = new LinkedTransferQueue<PooledConnection>();
- //idle = new ArrayBlockingQueue<PooledConnection>(properties.getMaxActive(),false);
- } else {
- idle = new LinkedBlockingQueue<>();
- }
-
- initializePoolCleaner(properties);
-
- //create JMX MBean
- if (this.getPoolProperties().isJmxEnabled()) createMBean();
-
- //Parse and create an initial set of interceptors. Letting them know the pool has started.
- //These interceptors will not get any connection.
- PoolProperties.InterceptorDefinition[] proxies = getPoolProperties().getJdbcInterceptorsAsArray();
- for (int i=0; i<proxies.length; i++) {
- try {
- if (log.isDebugEnabled()) {
- log.debug("Creating interceptor instance of class:"+proxies[i].getInterceptorClass());
- }
- JdbcInterceptor interceptor = proxies[i].getInterceptorClass().newInstance();
- interceptor.setProperties(proxies[i].getProperties());
- interceptor.poolStarted(this);
- }catch (Exception x) {
- log.error("Unable to inform interceptor of pool start.",x);
- if (jmxPool!=null) jmxPool.notify(org.apache.tomcat.jdbc.pool.jmx.ConnectionPool.NOTIFY_INIT, getStackTrace(x));
- close(true);
- SQLException ex = new SQLException();
- ex.initCause(x);
- throw ex;
- }
- }
-
- //initialize the pool with its initial set of members
- PooledConnection[] initialPool = new PooledConnection[poolProperties.getInitialSize()];
- try {
- for (int i = 0; i < initialPool.length; i++) {
- initialPool[i] = this.borrowConnection(0, null, null); //don't wait, should be no contention
- } //for
-
- } catch (SQLException x) {
- log.error("Unable to create initial connections of pool.", x);
- if (!poolProperties.isIgnoreExceptionOnPreLoad()) {
- if (jmxPool!=null) jmxPool.notify(org.apache.tomcat.jdbc.pool.jmx.ConnectionPool.NOTIFY_INIT, getStackTrace(x));
- close(true);
- throw x;
- }
- } finally {
- //return the members as idle to the pool
- for (int i = 0; i < initialPool.length; i++) {
- if (initialPool[i] != null) {
- try {this.returnConnection(initialPool[i]);}catch(Exception x){/*NOOP*/}
- } //end if
- } //for
- } //catch
-
- closed = false;
- }
-
- public void checkPoolConfiguration(PoolConfiguration properties) {
- //make sure the pool is properly configured
- if (properties.getMaxActive()<1) {
- log.warn("maxActive is smaller than 1, setting maxActive to: "+PoolProperties.DEFAULT_MAX_ACTIVE);
- properties.setMaxActive(PoolProperties.DEFAULT_MAX_ACTIVE);
- }
- if (properties.getMaxActive()<properties.getInitialSize()) {
- log.warn("initialSize is larger than maxActive, setting initialSize to: "+properties.getMaxActive());
- properties.setInitialSize(properties.getMaxActive());
- }
- if (properties.getMinIdle()>properties.getMaxActive()) {
- log.warn("minIdle is larger than maxActive, setting minIdle to: "+properties.getMaxActive());
- properties.setMinIdle(properties.getMaxActive());
- }
- if (properties.getMaxIdle()>properties.getMaxActive()) {
- log.warn("maxIdle is larger than maxActive, setting maxIdle to: "+properties.getMaxActive());
- properties.setMaxIdle(properties.getMaxActive());
- }
- if (properties.getMaxIdle()<properties.getMinIdle()) {
- log.warn("maxIdle is smaller than minIdle, setting maxIdle to: "+properties.getMinIdle());
- properties.setMaxIdle(properties.getMinIdle());
- }
- }
-
- public void initializePoolCleaner(PoolConfiguration properties) {
- //if the evictor thread is supposed to run, start it now
- if (properties.isPoolSweeperEnabled()) {
- poolCleaner = new PoolCleaner(this, properties.getTimeBetweenEvictionRunsMillis());
- poolCleaner.start();
- } //end if
- }
-
- public void terminatePoolCleaner() {
- if (poolCleaner!= null) {
- poolCleaner.stopRunning();
- poolCleaner = null;
- }
- }
-
-
-//===============================================================================
-// CONNECTION POOLING IMPL LOGIC
-//===============================================================================
-
- /**
- * thread safe way to abandon a connection
- * signals a connection to be abandoned.
- * this will disconnect the connection, and log the stack trace if logAbandoned=true
- * @param con PooledConnection
- */
- protected void abandon(PooledConnection con) {
- if (con == null)
- return;
- try {
- con.lock();
- String trace = con.getStackTrace();
- if (getPoolProperties().isLogAbandoned()) {
- log.warn("Connection has been abandoned " + con + ":" + trace);
- }
- if (jmxPool!=null) {
- jmxPool.notify(org.apache.tomcat.jdbc.pool.jmx.ConnectionPool.NOTIFY_ABANDON, trace);
- }
- //release the connection
- removeAbandonedCount.incrementAndGet();
- release(con);
- } finally {
- con.unlock();
- }
- }
-
- /**
- * Thread safe way to suspect a connection. Similar to
- * {@link #abandon(PooledConnection)}, but instead of actually abandoning
- * the connection, this will log a warning and set the suspect flag on the
- * {@link PooledConnection} if logAbandoned=true
- *
- * @param con PooledConnection
- */
- protected void suspect(PooledConnection con) {
- if (con == null)
- return;
- if (con.isSuspect())
- return;
- try {
- con.lock();
- String trace = con.getStackTrace();
- if (getPoolProperties().isLogAbandoned()) {
- log.warn("Connection has been marked suspect, possibly abandoned " + con + "["+(System.currentTimeMillis()-con.getTimestamp())+" ms.]:" + trace);
- }
- if (jmxPool!=null) {
- jmxPool.notify(org.apache.tomcat.jdbc.pool.jmx.ConnectionPool.SUSPECT_ABANDONED_NOTIFICATION, trace);
- }
- con.setSuspect(true);
- } finally {
- con.unlock();
- }
- }
-
- /**
- * thread safe way to release a connection
- * @param con PooledConnection
- */
- protected void release(PooledConnection con) {
- if (con == null)
- return;
- try {
- con.lock();
- if (con.release()) {
- //counter only decremented once
- size.addAndGet(-1);
- con.setHandler(null);
- }
- releasedCount.incrementAndGet();
- } finally {
- con.unlock();
- }
- // we've asynchronously reduced the number of connections
- // we could have threads stuck in idle.poll(timeout) that will never be
- // notified
- if (waitcount.get() > 0) {
- idle.offer(create(true));
- }
- }
-
- /**
- * Thread safe way to retrieve a connection from the pool
- * @param wait - time to wait, overrides the maxWait from the properties,
- * set to -1 if you wish to use maxWait, 0 if you wish no wait time.
- * @param username The user name to use for the connection
- * @param password The password for the connection
- * @return a connection
- * @throws SQLException Failed to get a connection
- */
- private PooledConnection borrowConnection(int wait, String username, String password) throws SQLException {
-
- if (isClosed()) {
- throw new SQLException("Connection pool closed.");
- } //end if
-
- //get the current time stamp
- long now = System.currentTimeMillis();
- //see if there is one available immediately
- PooledConnection con = idle.poll();
-
- while (true) {
- if (con!=null) {
- //configure the connection and return it
- PooledConnection result = borrowConnection(now, con, username, password);
- borrowedCount.incrementAndGet();
- if (result!=null) return result;
- }
-
- //if we get here, see if we need to create one
- //this is not 100% accurate since it doesn't use a shared
- //atomic variable - a connection can become idle while we are creating
- //a new connection
- if (size.get() < getPoolProperties().getMaxActive()) {
- //atomic duplicate check
- if (size.addAndGet(1) > getPoolProperties().getMaxActive()) {
- //if we got here, two threads passed through the first if
- size.decrementAndGet();
- } else {
- //create a connection, we're below the limit
- return createConnection(now, con, username, password);
- }
- } //end if
-
- //calculate wait time for this iteration
- long maxWait = wait;
- //if the passed in wait time is -1, means we should use the pool property value
- if (wait==-1) {
- maxWait = (getPoolProperties().getMaxWait()<=0)?Long.MAX_VALUE:getPoolProperties().getMaxWait();
- }
-
- long timetowait = Math.max(0, maxWait - (System.currentTimeMillis() - now));
- waitcount.incrementAndGet();
- try {
- //retrieve an existing connection
- con = idle.poll(timetowait, TimeUnit.MILLISECONDS);
- } catch (InterruptedException ex) {
- if (getPoolProperties().getPropagateInterruptState()) {
- Thread.currentThread().interrupt();
- }
- SQLException sx = new SQLException("Pool wait interrupted.");
- sx.initCause(ex);
- throw sx;
- } finally {
- waitcount.decrementAndGet();
- }
- if (maxWait==0 && con == null) { //no wait, return one if we have one
- if (jmxPool!=null) {
- jmxPool.notify(org.apache.tomcat.jdbc.pool.jmx.ConnectionPool.POOL_EMPTY, "Pool empty - no wait.");
- }
- throw new PoolExhaustedException("[" + Thread.currentThread().getName()+"] " +
- "NoWait: Pool empty. Unable to fetch a connection, none available["+busy.size()+" in use].");
- }
- //we didn't get a connection, lets see if we timed out
- if (con == null) {
- if ((System.currentTimeMillis() - now) >= maxWait) {
- if (jmxPool!=null) {
- jmxPool.notify(org.apache.tomcat.jdbc.pool.jmx.ConnectionPool.POOL_EMPTY, "Pool empty - timeout.");
- }
- throw new PoolExhaustedException("[" + Thread.currentThread().getName()+"] " +
- "Timeout: Pool empty. Unable to fetch a connection in " + (maxWait / 1000) +
- " seconds, none available[size:"+size.get() +"; busy:"+busy.size()+"; idle:"+idle.size()+"; lastwait:"+timetowait+"].");
- } else {
- //no timeout, lets try again
- continue;
- }
- }
- } //while
- }
-
- /**
- * Creates a JDBC connection and tries to connect to the database.
- * @param now timestamp of when this was called
- * @param notUsed Argument not used
- * @param username The user name to use for the connection
- * @param password The password for the connection
- * @return a PooledConnection that has been connected
- * @throws SQLException Failed to get a connection
- */
- protected PooledConnection createConnection(long now, PooledConnection notUsed, String username, String password) throws SQLException {
- //no connections where available we'll create one
- PooledConnection con = create(false);
- if (username!=null) con.getAttributes().put(PooledConnection.PROP_USER, username);
- if (password!=null) con.getAttributes().put(PooledConnection.PROP_PASSWORD, password);
- boolean error = false;
- try {
- //connect and validate the connection
- con.lock();
- con.connect();
- if (con.validate(PooledConnection.VALIDATE_INIT)) {
- //no need to lock a new one, its not contented
- con.setTimestamp(now);
- if (getPoolProperties().isLogAbandoned()) {
- con.setStackTrace(getThreadDump());
- }
- if (!busy.offer(con)) {
- log.debug("Connection doesn't fit into busy array, connection will not be traceable.");
- }
- createdCount.incrementAndGet();
- return con;
- } else {
- //validation failed, make sure we disconnect
- //and clean up
- throw new SQLException("Validation Query Failed, enable logValidationErrors for more details.");
- } //end if
- } catch (Exception e) {
- error = true;
- if (log.isDebugEnabled())
- log.debug("Unable to create a new JDBC connection.", e);
- if (e instanceof SQLException) {
- throw (SQLException)e;
- } else {
- SQLException ex = new SQLException(e.getMessage());
- ex.initCause(e);
- throw ex;
- }
- } finally {
- // con can never be null here
- if (error ) {
- release(con);
- }
- con.unlock();
- }//catch
- }
-
- /**
- * Validates and configures a previously idle connection
- * @param now - timestamp
- * @param con - the connection to validate and configure
- * @param username The user name to use for the connection
- * @param password The password for the connection
- * @return a connection
- * @throws SQLException if a validation error happens
- */
- protected PooledConnection borrowConnection(long now, PooledConnection con, String username, String password) throws SQLException {
- //we have a connection, lets set it up
-
- //flag to see if we need to nullify
- boolean setToNull = false;
- try {
- con.lock();
- if (con.isReleased()) {
- return null;
- }
-
- //evaluate username/password change as well as max age functionality
- boolean forceReconnect = con.shouldForceReconnect(username, password) || con.isMaxAgeExpired();
-
- if (!con.isDiscarded() && !con.isInitialized()) {
- //here it states that the connection not discarded, but the connection is null
- //don't attempt a connect here. It will be done during the reconnect.
- forceReconnect = true;
- }
-
- if (!forceReconnect) {
- if ((!con.isDiscarded()) && con.validate(PooledConnection.VALIDATE_BORROW)) {
- //set the timestamp
- con.setTimestamp(now);
- if (getPoolProperties().isLogAbandoned()) {
- //set the stack trace for this pool
- con.setStackTrace(getThreadDump());
- }
- if (!busy.offer(con)) {
- log.debug("Connection doesn't fit into busy array, connection will not be traceable.");
- }
- return con;
- }
- }
- //if we reached here, that means the connection
- //is either has another principal, is discarded or validation failed.
- //we will make one more attempt
- //in order to guarantee that the thread that just acquired
- //the connection shouldn't have to poll again.
- try {
- con.reconnect();
- reconnectedCount.incrementAndGet();
- int validationMode = getPoolProperties().isTestOnConnect() || getPoolProperties().getInitSQL()!=null ?
- PooledConnection.VALIDATE_INIT :
- PooledConnection.VALIDATE_BORROW;
-
- if (con.validate(validationMode)) {
- //set the timestamp
- con.setTimestamp(now);
- if (getPoolProperties().isLogAbandoned()) {
- //set the stack trace for this pool
- con.setStackTrace(getThreadDump());
- }
- if (!busy.offer(con)) {
- log.debug("Connection doesn't fit into busy array, connection will not be traceable.");
- }
- return con;
- } else {
- //validation failed.
- throw new SQLException("Failed to validate a newly established connection.");
- }
- } catch (Exception x) {
- release(con);
- setToNull = true;
- if (x instanceof SQLException) {
- throw (SQLException)x;
- } else {
- SQLException ex = new SQLException(x.getMessage());
- ex.initCause(x);
- throw ex;
- }
- }
- } finally {
- con.unlock();
- if (setToNull) {
- con = null;
- }
- }
- }
- /**
- * Terminate the current transaction for the given connection.
- * @param con The connection
- * @return <code>true</code> if the connection TX termination succeeded
- * otherwise <code>false</code>
- */
- protected boolean terminateTransaction(PooledConnection con) {
- try {
- if (Boolean.FALSE.equals(con.getPoolProperties().getDefaultAutoCommit())) {
- if (this.getPoolProperties().getRollbackOnReturn()) {
- boolean autocommit = con.getConnection().getAutoCommit();
- if (!autocommit) con.getConnection().rollback();
- } else if (this.getPoolProperties().getCommitOnReturn()) {
- boolean autocommit = con.getConnection().getAutoCommit();
- if (!autocommit) con.getConnection().commit();
- }
- }
- return true;
- } catch (SQLException x) {
- log.warn("Unable to terminate transaction, connection will be closed.",x);
- return false;
- }
-
- }
-
- /**
- * Determines if a connection should be closed upon return to the pool.
- * @param con - the connection
- * @param action - the validation action that should be performed
- * @return <code>true</code> if the connection should be closed
- */
- protected boolean shouldClose(PooledConnection con, int action) {
- if (con.getConnectionVersion() < getPoolVersion()) return true;
- if (con.isDiscarded()) return true;
- if (isClosed()) return true;
- if (!con.validate(action)) return true;
- if (!terminateTransaction(con)) return true;
- if (con.isMaxAgeExpired()) return true;
- else return false;
- }
-
- /**
- * Returns a connection to the pool
- * If the pool is closed, the connection will be released
- * If the connection is not part of the busy queue, it will be released.
- * If {@link PoolProperties#testOnReturn} is set to true it will be validated
- * @param con PooledConnection to be returned to the pool
- */
- protected void returnConnection(PooledConnection con) {
- if (isClosed()) {
- //if the connection pool is closed
- //close the connection instead of returning it
- release(con);
- return;
- } //end if
-
- if (con != null) {
- try {
- returnedCount.incrementAndGet();
- con.lock();
- if (con.isSuspect()) {
- if (poolProperties.isLogAbandoned() && log.isInfoEnabled()) {
- log.info("Connection(" + con + ") that has been marked suspect was returned."
- + " The processing time is " + (System.currentTimeMillis()-con.getTimestamp()) + " ms.");
- }
- if (jmxPool!=null) {
- jmxPool.notify(org.apache.tomcat.jdbc.pool.jmx.ConnectionPool.SUSPECT_RETURNED_NOTIFICATION,
- "Connection(" + con + ") that has been marked suspect was returned.");
- }
- }
- if (busy.remove(con)) {
-
- if (!shouldClose(con,PooledConnection.VALIDATE_RETURN)) {
- con.setStackTrace(null);
- con.setTimestamp(System.currentTimeMillis());
- if (((idle.size()>=poolProperties.getMaxIdle()) && !poolProperties.isPoolSweeperEnabled()) || (!idle.offer(con))) {
- if (log.isDebugEnabled()) {
- log.debug("Connection ["+con+"] will be closed and not returned to the pool, idle["+idle.size()+"]>=maxIdle["+poolProperties.getMaxIdle()+"] idle.offer failed.");
- }
- release(con);
- }
- } else {
- if (log.isDebugEnabled()) {
- log.debug("Connection ["+con+"] will be closed and not returned to the pool.");
- }
- release(con);
- } //end if
- } else {
- if (log.isDebugEnabled()) {
- log.debug("Connection ["+con+"] will be closed and not returned to the pool, busy.remove failed.");
- }
- release(con);
- }
- } finally {
- con.unlock();
- }
- } //end if
- } //checkIn
-
- /**
- * Determines if a connection should be abandoned based on
- * {@link PoolProperties#abandonWhenPercentageFull} setting.
- * @return <code>true</code> if the connection should be abandoned
- */
- protected boolean shouldAbandon() {
- if (!poolProperties.isRemoveAbandoned()) return false;
- if (poolProperties.getAbandonWhenPercentageFull()==0) return true;
- float used = busy.size();
- float max = poolProperties.getMaxActive();
- float perc = poolProperties.getAbandonWhenPercentageFull();
- return (used/max*100f)>=perc;
- }
-
- /**
- * Iterates through all the busy connections and checks for connections that have timed out
- */
- public void checkAbandoned() {
- try {
- if (busy.size()==0) return;
- Iterator<PooledConnection> locked = busy.iterator();
- int sto = getPoolProperties().getSuspectTimeout();
- while (locked.hasNext()) {
- PooledConnection con = locked.next();
- boolean setToNull = false;
- try {
- con.lock();
- //the con has been returned to the pool or released
- //ignore it
- if (idle.contains(con) || con.isReleased())
- continue;
- long time = con.getTimestamp();
- long now = System.currentTimeMillis();
- if (shouldAbandon() && (now - time) > con.getAbandonTimeout()) {
- busy.remove(con);
- abandon(con);
- setToNull = true;
- } else if (sto > 0 && (now - time) > (sto * 1000L)) {
- suspect(con);
- } else {
- //do nothing
- } //end if
- } finally {
- con.unlock();
- if (setToNull)
- con = null;
- }
- } //while
- } catch (ConcurrentModificationException e) {
- log.debug("checkAbandoned failed." ,e);
- } catch (Exception e) {
- log.warn("checkAbandoned failed, it will be retried.",e);
- }
- }
-
- /**
- * Iterates through the idle connections and resizes the idle pool based on parameters
- * {@link PoolProperties#maxIdle}, {@link PoolProperties#minIdle}, {@link PoolProperties#minEvictableIdleTimeMillis}
- */
- public void checkIdle() {
- checkIdle(false);
- }
-
- public void checkIdle(boolean ignoreMinSize) {
-
- try {
- if (idle.size()==0) return;
- long now = System.currentTimeMillis();
- Iterator<PooledConnection> unlocked = idle.iterator();
- while ( (ignoreMinSize || (idle.size()>=getPoolProperties().getMinIdle())) && unlocked.hasNext()) {
- PooledConnection con = unlocked.next();
- boolean setToNull = false;
- try {
- con.lock();
- //the con been taken out, we can't clean it up
- if (busy.contains(con))
- continue;
- long time = con.getTimestamp();
- if (shouldReleaseIdle(now, con, time)) {
- releasedIdleCount.incrementAndGet();
- release(con);
- idle.remove(con);
- setToNull = true;
- } else {
- //do nothing
- } //end if
- } finally {
- con.unlock();
- if (setToNull)
- con = null;
- }
- } //while
- } catch (ConcurrentModificationException e) {
- log.debug("checkIdle failed." ,e);
- } catch (Exception e) {
- log.warn("checkIdle failed, it will be retried.",e);
- }
-
- }
-
-
- protected boolean shouldReleaseIdle(long now, PooledConnection con, long time) {
- if (con.getConnectionVersion() < getPoolVersion()) return true;
- else return (con.getReleaseTime()>0) && ((now - time) > con.getReleaseTime()) && (getSize()>getPoolProperties().getMinIdle());
- }
-
- /**
- * Forces a validation of all idle connections if {@link PoolProperties#testWhileIdle} is set.
- */
- public void testAllIdle() {
- try {
- if (idle.size()==0) return;
- Iterator<PooledConnection> unlocked = idle.iterator();
- while (unlocked.hasNext()) {
- PooledConnection con = unlocked.next();
- try {
- con.lock();
- //the con been taken out, we can't clean it up
- if (busy.contains(con))
- continue;
- if (!con.validate(PooledConnection.VALIDATE_IDLE)) {
- idle.remove(con);
- release(con);
- }
- } finally {
- con.unlock();
- }
- } //while
- } catch (ConcurrentModificationException e) {
- log.debug("testAllIdle failed." ,e);
- } catch (Exception e) {
- log.warn("testAllIdle failed, it will be retried.",e);
- }
-
- }
-
- /**
- * Creates a stack trace representing the existing thread's current state.
- * @return a string object representing the current state.
- * TODO investigate if we simply should store {@link java.lang.Thread#getStackTrace()} elements
- */
- protected static String getThreadDump() {
- Exception x = new Exception();
- x.fillInStackTrace();
- return getStackTrace(x);
- }
-
- /**
- * Convert an exception into a String
- * @param x - the throwable
- * @return a string representing the stack trace
- */
- public static String getStackTrace(Throwable x) {
- if (x == null) {
- return null;
- } else {
- java.io.ByteArrayOutputStream bout = new java.io.ByteArrayOutputStream();
- java.io.PrintStream writer = new java.io.PrintStream(bout);
- x.printStackTrace(writer);
- String result = bout.toString();
- return (x.getMessage()!=null && x.getMessage().length()>0)? x.getMessage()+";"+result:result;
- } //end if
- }
-
-
- /**
- * Create a new pooled connection object. Not connected nor validated.
- * @param incrementCounter <code>true</code> to increment the connection count
- * @return a pooled connection object
- */
- protected PooledConnection create(boolean incrementCounter) {
- if (incrementCounter) size.incrementAndGet();
- PooledConnection con = new PooledConnection(getPoolProperties(), this);
- return con;
- }
-
- /**
- * Purges all connections in the pool.
- * For connections currently in use, these connections will be
- * purged when returned on the pool. This call also
- * purges connections that are idle and in the pool
- * To only purge used/active connections see {@link #purgeOnReturn()}
- */
- public void purge() {
- purgeOnReturn();
- checkIdle(true);
- }
-
- /**
- * Purges connections when they are returned from the pool.
- * This call does not purge idle connections until they are used.
- * To purge idle connections see {@link #purge()}
- */
- public void purgeOnReturn() {
- poolVersion.incrementAndGet();
- }
-
- /**
- * Hook to perform final actions on a pooled connection object once it has been disconnected and will be discarded
- * @param con The connection
- */
- protected void finalize(PooledConnection con) {
- JdbcInterceptor handler = con.getHandler();
- while (handler!=null) {
- handler.reset(null, null);
- handler=handler.getNext();
- }
- }
-
- /**
- * Hook to perform final actions on a pooled connection object once it has been disconnected and will be discarded
- * @param con The connection
- * @param finalizing <code>true</code> if finalizing the connection
- */
- protected void disconnectEvent(PooledConnection con, boolean finalizing) {
- JdbcInterceptor handler = con.getHandler();
- while (handler!=null) {
- handler.disconnected(this, con, finalizing);
- handler=handler.getNext();
- }
- }
-
- /**
- * Return the object that is potentially registered in JMX for notifications
- * @return the object implementing the {@link org.apache.tomcat.jdbc.pool.jmx.ConnectionPoolMBean} interface
- */
- public org.apache.tomcat.jdbc.pool.jmx.ConnectionPool getJmxPool() {
- return jmxPool;
- }
-
- /**
- * Create MBean object that can be registered.
- */
- protected void createMBean() {
- try {
- jmxPool = new org.apache.tomcat.jdbc.pool.jmx.ConnectionPool(this);
- } catch (Exception x) {
- log.warn("Unable to start JMX integration for connection pool. Instance["+getName()+"] can't be monitored.",x);
- }
- }
-
- /**
- * The total number of connections borrowed from this pool.
- * @return the borrowed connection count
- */
- public long getBorrowedCount() {
- return borrowedCount.get();
- }
-
- /**
- * The total number of connections returned to this pool.
- * @return the returned connection count
- */
- public long getReturnedCount() {
- return returnedCount.get();
- }
-
- /**
- * The total number of connections created by this pool.
- * @return the created connection count
- */
- public long getCreatedCount() {
- return createdCount.get();
- }
-
- /**
- * The total number of connections released from this pool.
- * @return the released connection count
- */
- public long getReleasedCount() {
- return releasedCount.get();
- }
-
- /**
- * The total number of connections reconnected by this pool.
- * @return the reconnected connection count
- */
- public long getReconnectedCount() {
- return reconnectedCount.get();
- }
-
- /**
- * The total number of connections released by remove abandoned.
- * @return the PoolCleaner removed abandoned connection count
- */
- public long getRemoveAbandonedCount() {
- return removeAbandonedCount.get();
- }
-
- /**
- * The total number of connections released by eviction.
- * @return the PoolCleaner evicted idle connection count
- */
- public long getReleasedIdleCount() {
- return releasedIdleCount.get();
- }
-
- /**
- * reset the statistics of this pool.
- */
- public void resetStats() {
- borrowedCount.set(0);
- returnedCount.set(0);
- createdCount.set(0);
- releasedCount.set(0);
- reconnectedCount.set(0);
- removeAbandonedCount.set(0);
- releasedIdleCount.set(0);
- }
-
- /**
- * Tread safe wrapper around a future for the regular queue
- * This one retrieves the pooled connection object
- * and performs the initialization according to
- * interceptors and validation rules.
- * This class is thread safe and is cancellable
- *
- */
- protected class ConnectionFuture implements Future<Connection>, Runnable {
- Future<PooledConnection> pcFuture = null;
- AtomicBoolean configured = new AtomicBoolean(false);
- CountDownLatch latch = new CountDownLatch(1);
- volatile Connection result = null;
- SQLException cause = null;
- AtomicBoolean cancelled = new AtomicBoolean(false);
- volatile PooledConnection pc = null;
- public ConnectionFuture(Future<PooledConnection> pcf) {
- this.pcFuture = pcf;
- }
-
- public ConnectionFuture(PooledConnection pc) throws SQLException {
- this.pc = pc;
- result = ConnectionPool.this.setupConnection(pc);
- configured.set(true);
- }
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean cancel(boolean mayInterruptIfRunning) {
- if (pc!=null) {
- return false;
- } else if ((!cancelled.get()) && cancelled.compareAndSet(false, true)) {
- //cancel by retrieving the connection and returning it to the pool
- ConnectionPool.this.cancellator.execute(this);
- }
- return true;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Connection get() throws InterruptedException, ExecutionException {
- try {
- return get(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
- }catch (TimeoutException x) {
- throw new ExecutionException(x);
- }
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Connection get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
- PooledConnection pc = this.pc!=null?this.pc:pcFuture.get(timeout,unit);
- if (pc!=null) {
- if (result!=null) return result;
- if (configured.compareAndSet(false, true)) {
- try {
- pc = borrowConnection(System.currentTimeMillis(),pc, null, null);
- result = ConnectionPool.this.setupConnection(pc);
- } catch (SQLException x) {
- cause = x;
- } finally {
- latch.countDown();
- }
- } else {
- //if we reach here, another thread is configuring the actual connection
- latch.await(timeout,unit); //this shouldn't block for long
- }
- if (result==null) throw new ExecutionException(cause);
- return result;
- } else {
- return null;
- }
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isCancelled() {
- return pc==null && (pcFuture.isCancelled() || cancelled.get());
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isDone() {
- return pc!=null || pcFuture.isDone();
- }
-
- /**
- * run method to be executed when cancelled by an executor
- */
- @Override
- public void run() {
- try {
- Connection con = get(); //complete this future
- con.close(); //return to the pool
- }catch (ExecutionException ex) {
- //we can ignore this
- }catch (Exception x) {
- ConnectionPool.log.error("Unable to cancel ConnectionFuture.",x);
- }
- }
-
- }
-
-
-
- private static volatile Timer poolCleanTimer = null;
- private static HashSet<PoolCleaner> cleaners = new HashSet<>();
-
- private static synchronized void registerCleaner(PoolCleaner cleaner) {
- unregisterCleaner(cleaner);
- cleaners.add(cleaner);
- if (poolCleanTimer == null) {
- ClassLoader loader = Thread.currentThread().getContextClassLoader();
- try {
- Thread.currentThread().setContextClassLoader(ConnectionPool.class.getClassLoader());
- // Create the timer thread in a PrivilegedAction so that a
- // reference to the web application class loader is not created
- // via Thread.inheritedAccessControlContext
- PrivilegedAction<Timer> pa = new PrivilegedNewTimer();
- poolCleanTimer = AccessController.doPrivileged(pa);
- } finally {
- Thread.currentThread().setContextClassLoader(loader);
- }
- }
- poolCleanTimer.schedule(cleaner, cleaner.sleepTime,cleaner.sleepTime);
- }
-
- private static synchronized void unregisterCleaner(PoolCleaner cleaner) {
- boolean removed = cleaners.remove(cleaner);
- if (removed) {
- cleaner.cancel();
- if (poolCleanTimer != null) {
- poolCleanTimer.purge();
- if (cleaners.size() == 0) {
- poolCleanTimer.cancel();
- poolCleanTimer = null;
- }
- }
- }
- }
-
- private static class PrivilegedNewTimer implements PrivilegedAction<Timer> {
- @Override
- public Timer run() {
- return new Timer("Tomcat JDBC Pool Cleaner["+ System.identityHashCode(ConnectionPool.class.getClassLoader()) + ":"+
- System.currentTimeMillis() + "]", true);
- }
- }
-
- public static Set<TimerTask> getPoolCleaners() {
- return Collections.<TimerTask>unmodifiableSet(cleaners);
- }
-
- public long getPoolVersion() {
- return poolVersion.get();
- }
-
- public static Timer getPoolTimer() {
- return poolCleanTimer;
- }
-
- protected static class PoolCleaner extends TimerTask {
- protected WeakReference<ConnectionPool> pool;
- protected long sleepTime;
-
- PoolCleaner(ConnectionPool pool, long sleepTime) {
- this.pool = new WeakReference<>(pool);
- this.sleepTime = sleepTime;
- if (sleepTime <= 0) {
- log.warn("Database connection pool evicter thread interval is set to 0, defaulting to 30 seconds");
- this.sleepTime = 1000 * 30;
- } else if (sleepTime < 1000) {
- log.warn("Database connection pool evicter thread interval is set to lower than 1 second.");
- }
- }
-
- @Override
- public void run() {
- ConnectionPool pool = this.pool.get();
- if (pool == null) {
- stopRunning();
- } else if (!pool.isClosed()) {
- try {
- if (pool.getPoolProperties().isRemoveAbandoned()
- || pool.getPoolProperties().getSuspectTimeout() > 0)
- pool.checkAbandoned();
- if (pool.getPoolProperties().getMinIdle() < pool.idle
- .size())
- pool.checkIdle();
- if (pool.getPoolProperties().isTestWhileIdle())
- pool.testAllIdle();
- } catch (Exception x) {
- log.error("", x);
- }
- }
- }
-
- public void start() {
- registerCleaner(this);
- }
-
- public void stopRunning() {
- unregisterCleaner(this);
- }
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.lang.management.ManagementFactory;
-import java.util.Hashtable;
-
-import javax.management.InstanceNotFoundException;
-import javax.management.MBeanRegistration;
-import javax.management.MBeanServer;
-import javax.management.MalformedObjectNameException;
-import javax.management.ObjectName;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-
-
-/**
- * A DataSource that can be instantiated through IoC and implements the DataSource interface
- * since the DataSourceProxy is used as a generic proxy.
- * The DataSource simply wraps a {@link ConnectionPool} in order to provide a standard interface to the user.
- * @version 1.0
- */
-public class DataSource extends DataSourceProxy implements javax.sql.DataSource,MBeanRegistration, org.apache.tomcat.jdbc.pool.jmx.ConnectionPoolMBean, javax.sql.ConnectionPoolDataSource {
- private static final Log log = LogFactory.getLog(DataSource.class);
-
- /**
- * Constructor for reflection only. A default set of pool properties will be created.
- */
- public DataSource() {
- super();
- }
-
- /**
- * Constructs a DataSource object wrapping a connection
- * @param poolProperties The pool properties
- */
- public DataSource(PoolConfiguration poolProperties) {
- super(poolProperties);
- }
-
-
-
-
-
-//===============================================================================
-// JMX Operations - Register the actual pool itself under the tomcat.jdbc domain
-//===============================================================================
- protected volatile ObjectName oname = null;
-
- /**
- * Unregisters the underlying connection pool mbean.<br>
- * {@inheritDoc}
- */
- @Override
- public void postDeregister() {
- if (oname!=null) unregisterJmx();
- }
-
- /**
- * no-op<br>
- * {@inheritDoc}
- */
- @Override
- public void postRegister(Boolean registrationDone) {
- // NOOP
- }
-
-
- /**
- * no-op<br>
- * {@inheritDoc}
- */
- @Override
- public void preDeregister() throws Exception {
- // NOOP
- }
-
- /**
- * If the connection pool MBean exists, it will be registered during this operation.<br>
- * {@inheritDoc}
- */
- @Override
- public ObjectName preRegister(MBeanServer server, ObjectName name) throws Exception {
- try {
- if ( isJmxEnabled() ) {
- this.oname = createObjectName(name);
- if (oname!=null) registerJmx();
- }
- }catch (MalformedObjectNameException x) {
- log.error("Unable to create object name for JDBC pool.",x);
- }
- return name;
- }
-
- /**
- * Creates the ObjectName for the ConnectionPoolMBean object to be registered
- * @param original the ObjectName for the DataSource
- * @return the ObjectName for the ConnectionPoolMBean
- * @throws MalformedObjectNameException Invalid object name
- */
- public ObjectName createObjectName(ObjectName original) throws MalformedObjectNameException {
- String domain = ConnectionPool.POOL_JMX_DOMAIN;
- Hashtable<String,String> properties = original.getKeyPropertyList();
- String origDomain = original.getDomain();
- properties.put("type", "ConnectionPool");
- properties.put("class", this.getClass().getName());
- if (original.getKeyProperty("path")!=null || properties.get("context")!=null) {
- //this ensures that if the registration came from tomcat, we're not losing
- //the unique domain, but putting that into as an engine attribute
- properties.put("engine", origDomain);
- }
- ObjectName name = new ObjectName(domain,properties);
- return name;
- }
-
- /**
- * Registers the ConnectionPoolMBean under a unique name based on the ObjectName for the DataSource
- */
- protected void registerJmx() {
- try {
- if (pool.getJmxPool()!=null) {
- MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
- mbs.registerMBean(pool.getJmxPool(), oname);
- }
- } catch (Exception e) {
- log.error("Unable to register JDBC pool with JMX",e);
- }
- }
-
- /**
- *
- */
- protected void unregisterJmx() {
- try {
- MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
- mbs.unregisterMBean(oname);
- } catch (InstanceNotFoundException ignore) {
- // NOOP
- } catch (Exception e) {
- log.error("Unable to unregister JDBC pool with JMX",e);
- }
- }
-
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-
-import java.sql.Connection;
-import java.util.Hashtable;
-import java.util.Properties;
-
-import javax.management.ObjectName;
-import javax.naming.Context;
-import javax.naming.InitialContext;
-import javax.naming.Name;
-import javax.naming.NamingException;
-import javax.naming.RefAddr;
-import javax.naming.Reference;
-import javax.naming.spi.ObjectFactory;
-import javax.sql.DataSource;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-
-/**
- * <p>JNDI object factory that creates an instance of
- * <code>BasicDataSource</code> that has been configured based on the
- * <code>RefAddr</code> values of the specified <code>Reference</code>,
- * which must match the names and data types of the
- * <code>BasicDataSource</code> bean properties.</p>
- * <br>
- * Properties available for configuration:<br>
- * <a href="http://commons.apache.org/dbcp/configuration.html">Commons DBCP properties</a><br>
- *<ol>
- * <li>initSQL - A query that gets executed once, right after the connection is established.</li>
- * <li>testOnConnect - run validationQuery after connection has been established.</li>
- * <li>validationInterval - avoid excess validation, only run validation at most at this frequency - time in milliseconds.</li>
- * <li>jdbcInterceptors - a semicolon separated list of classnames extending {@link JdbcInterceptor} class.</li>
- * <li>jmxEnabled - true of false, whether to register the pool with JMX.</li>
- * <li>fairQueue - true of false, whether the pool should sacrifice a little bit of performance for true fairness.</li>
- *</ol>
- * @author Craig R. McClanahan
- * @author Dirk Verbeeck
- */
-public class DataSourceFactory implements ObjectFactory {
- private static final Log log = LogFactory.getLog(DataSourceFactory.class);
-
- protected static final String PROP_DEFAULTAUTOCOMMIT = "defaultAutoCommit";
- protected static final String PROP_DEFAULTREADONLY = "defaultReadOnly";
- protected static final String PROP_DEFAULTTRANSACTIONISOLATION = "defaultTransactionIsolation";
- protected static final String PROP_DEFAULTCATALOG = "defaultCatalog";
-
- protected static final String PROP_DRIVERCLASSNAME = "driverClassName";
- protected static final String PROP_PASSWORD = "password";
- protected static final String PROP_URL = "url";
- protected static final String PROP_USERNAME = "username";
-
- protected static final String PROP_MAXACTIVE = "maxActive";
- protected static final String PROP_MAXIDLE = "maxIdle";
- protected static final String PROP_MINIDLE = "minIdle";
- protected static final String PROP_INITIALSIZE = "initialSize";
- protected static final String PROP_MAXWAIT = "maxWait";
- protected static final String PROP_MAXAGE = "maxAge";
-
- protected static final String PROP_TESTONBORROW = "testOnBorrow";
- protected static final String PROP_TESTONRETURN = "testOnReturn";
- protected static final String PROP_TESTWHILEIDLE = "testWhileIdle";
- protected static final String PROP_TESTONCONNECT = "testOnConnect";
- protected static final String PROP_VALIDATIONQUERY = "validationQuery";
- protected static final String PROP_VALIDATIONQUERY_TIMEOUT = "validationQueryTimeout";
- protected static final String PROP_VALIDATOR_CLASS_NAME = "validatorClassName";
-
- protected static final String PROP_NUMTESTSPEREVICTIONRUN = "numTestsPerEvictionRun";
- protected static final String PROP_TIMEBETWEENEVICTIONRUNSMILLIS = "timeBetweenEvictionRunsMillis";
- protected static final String PROP_MINEVICTABLEIDLETIMEMILLIS = "minEvictableIdleTimeMillis";
-
- protected static final String PROP_ACCESSTOUNDERLYINGCONNECTIONALLOWED = "accessToUnderlyingConnectionAllowed";
-
- protected static final String PROP_REMOVEABANDONED = "removeAbandoned";
- protected static final String PROP_REMOVEABANDONEDTIMEOUT = "removeAbandonedTimeout";
- protected static final String PROP_LOGABANDONED = "logAbandoned";
- protected static final String PROP_ABANDONWHENPERCENTAGEFULL = "abandonWhenPercentageFull";
-
- protected static final String PROP_POOLPREPAREDSTATEMENTS = "poolPreparedStatements";
- protected static final String PROP_MAXOPENPREPAREDSTATEMENTS = "maxOpenPreparedStatements";
- protected static final String PROP_CONNECTIONPROPERTIES = "connectionProperties";
-
- protected static final String PROP_INITSQL = "initSQL";
- protected static final String PROP_INTERCEPTORS = "jdbcInterceptors";
- protected static final String PROP_VALIDATIONINTERVAL = "validationInterval";
- protected static final String PROP_JMX_ENABLED = "jmxEnabled";
- protected static final String PROP_FAIR_QUEUE = "fairQueue";
-
- protected static final String PROP_USE_EQUALS = "useEquals";
- protected static final String PROP_USE_CON_LOCK = "useLock";
-
- protected static final String PROP_DATASOURCE= "dataSource";
- protected static final String PROP_DATASOURCE_JNDI = "dataSourceJNDI";
-
- protected static final String PROP_SUSPECT_TIMEOUT = "suspectTimeout";
-
- protected static final String PROP_ALTERNATE_USERNAME_ALLOWED = "alternateUsernameAllowed";
-
- protected static final String PROP_COMMITONRETURN = "commitOnReturn";
- protected static final String PROP_ROLLBACKONRETURN = "rollbackOnReturn";
-
- protected static final String PROP_USEDISPOSABLECONNECTIONFACADE = "useDisposableConnectionFacade";
-
- protected static final String PROP_LOGVALIDATIONERRORS = "logValidationErrors";
-
- protected static final String PROP_PROPAGATEINTERRUPTSTATE = "propagateInterruptState";
-
- protected static final String PROP_IGNOREEXCEPTIONONPRELOAD = "ignoreExceptionOnPreLoad";
-
- public static final int UNKNOWN_TRANSACTIONISOLATION = -1;
-
- public static final String OBJECT_NAME = "object_name";
-
-
- protected static final String[] ALL_PROPERTIES = {
- PROP_DEFAULTAUTOCOMMIT,
- PROP_DEFAULTREADONLY,
- PROP_DEFAULTTRANSACTIONISOLATION,
- PROP_DEFAULTCATALOG,
- PROP_DRIVERCLASSNAME,
- PROP_MAXACTIVE,
- PROP_MAXIDLE,
- PROP_MINIDLE,
- PROP_INITIALSIZE,
- PROP_MAXWAIT,
- PROP_TESTONBORROW,
- PROP_TESTONRETURN,
- PROP_TIMEBETWEENEVICTIONRUNSMILLIS,
- PROP_NUMTESTSPEREVICTIONRUN,
- PROP_MINEVICTABLEIDLETIMEMILLIS,
- PROP_TESTWHILEIDLE,
- PROP_TESTONCONNECT,
- PROP_PASSWORD,
- PROP_URL,
- PROP_USERNAME,
- PROP_VALIDATIONQUERY,
- PROP_VALIDATIONQUERY_TIMEOUT,
- PROP_VALIDATOR_CLASS_NAME,
- PROP_VALIDATIONINTERVAL,
- PROP_ACCESSTOUNDERLYINGCONNECTIONALLOWED,
- PROP_REMOVEABANDONED,
- PROP_REMOVEABANDONEDTIMEOUT,
- PROP_LOGABANDONED,
- PROP_POOLPREPAREDSTATEMENTS,
- PROP_MAXOPENPREPAREDSTATEMENTS,
- PROP_CONNECTIONPROPERTIES,
- PROP_INITSQL,
- PROP_INTERCEPTORS,
- PROP_JMX_ENABLED,
- PROP_FAIR_QUEUE,
- PROP_USE_EQUALS,
- OBJECT_NAME,
- PROP_ABANDONWHENPERCENTAGEFULL,
- PROP_MAXAGE,
- PROP_USE_CON_LOCK,
- PROP_DATASOURCE,
- PROP_DATASOURCE_JNDI,
- PROP_SUSPECT_TIMEOUT,
- PROP_ALTERNATE_USERNAME_ALLOWED,
- PROP_COMMITONRETURN,
- PROP_ROLLBACKONRETURN,
- PROP_USEDISPOSABLECONNECTIONFACADE,
- PROP_LOGVALIDATIONERRORS,
- PROP_PROPAGATEINTERRUPTSTATE,
- PROP_IGNOREEXCEPTIONONPRELOAD
- };
-
- // -------------------------------------------------- ObjectFactory Methods
-
- /**
- * <p>Create and return a new <code>BasicDataSource</code> instance. If no
- * instance can be created, return <code>null</code> instead.</p>
- *
- * @param obj The possibly null object containing location or
- * reference information that can be used in creating an object
- * @param name The name of this object relative to <code>nameCtx</code>
- * @param nameCtx The context relative to which the <code>name</code>
- * parameter is specified, or <code>null</code> if <code>name</code>
- * is relative to the default initial context
- * @param environment The possibly null environment that is used in
- * creating this object
- *
- * @exception Exception if an exception occurs creating the instance
- */
- @Override
- public Object getObjectInstance(Object obj, Name name, Context nameCtx,
- Hashtable<?,?> environment) throws Exception {
-
- // We only know how to deal with <code>javax.naming.Reference</code>s
- // that specify a class name of "javax.sql.DataSource"
- if ((obj == null) || !(obj instanceof Reference)) {
- return null;
- }
- Reference ref = (Reference) obj;
- boolean XA = false;
- boolean ok = false;
- if ("javax.sql.DataSource".equals(ref.getClassName())) {
- ok = true;
- }
- if ("javax.sql.XADataSource".equals(ref.getClassName())) {
- ok = true;
- XA = true;
- }
- if (org.apache.tomcat.jdbc.pool.DataSource.class.getName().equals(ref.getClassName())) {
- ok = true;
- }
-
- if (!ok) {
- log.warn(ref.getClassName()+" is not a valid class name/type for this JNDI factory.");
- return null;
- }
-
-
- Properties properties = new Properties();
- for (int i = 0; i < ALL_PROPERTIES.length; i++) {
- String propertyName = ALL_PROPERTIES[i];
- RefAddr ra = ref.get(propertyName);
- if (ra != null) {
- String propertyValue = ra.getContent().toString();
- properties.setProperty(propertyName, propertyValue);
- }
- }
-
- return createDataSource(properties,nameCtx,XA);
- }
-
- public static PoolConfiguration parsePoolProperties(Properties properties) {
- PoolConfiguration poolProperties = new PoolProperties();
- String value = null;
-
- value = properties.getProperty(PROP_DEFAULTAUTOCOMMIT);
- if (value != null) {
- poolProperties.setDefaultAutoCommit(Boolean.valueOf(value));
- }
-
- value = properties.getProperty(PROP_DEFAULTREADONLY);
- if (value != null) {
- poolProperties.setDefaultReadOnly(Boolean.valueOf(value));
- }
-
- value = properties.getProperty(PROP_DEFAULTTRANSACTIONISOLATION);
- if (value != null) {
- int level = UNKNOWN_TRANSACTIONISOLATION;
- if ("NONE".equalsIgnoreCase(value)) {
- level = Connection.TRANSACTION_NONE;
- } else if ("READ_COMMITTED".equalsIgnoreCase(value)) {
- level = Connection.TRANSACTION_READ_COMMITTED;
- } else if ("READ_UNCOMMITTED".equalsIgnoreCase(value)) {
- level = Connection.TRANSACTION_READ_UNCOMMITTED;
- } else if ("REPEATABLE_READ".equalsIgnoreCase(value)) {
- level = Connection.TRANSACTION_REPEATABLE_READ;
- } else if ("SERIALIZABLE".equalsIgnoreCase(value)) {
- level = Connection.TRANSACTION_SERIALIZABLE;
- } else {
- try {
- level = Integer.parseInt(value);
- } catch (NumberFormatException e) {
- System.err.println("Could not parse defaultTransactionIsolation: " + value);
- System.err.println("WARNING: defaultTransactionIsolation not set");
- System.err.println("using default value of database driver");
- level = UNKNOWN_TRANSACTIONISOLATION;
- }
- }
- poolProperties.setDefaultTransactionIsolation(level);
- }
-
- value = properties.getProperty(PROP_DEFAULTCATALOG);
- if (value != null) {
- poolProperties.setDefaultCatalog(value);
- }
-
- value = properties.getProperty(PROP_DRIVERCLASSNAME);
- if (value != null) {
- poolProperties.setDriverClassName(value);
- }
-
- value = properties.getProperty(PROP_MAXACTIVE);
- if (value != null) {
- poolProperties.setMaxActive(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_MAXIDLE);
- if (value != null) {
- poolProperties.setMaxIdle(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_MINIDLE);
- if (value != null) {
- poolProperties.setMinIdle(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_INITIALSIZE);
- if (value != null) {
- poolProperties.setInitialSize(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_MAXWAIT);
- if (value != null) {
- poolProperties.setMaxWait(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_TESTONBORROW);
- if (value != null) {
- poolProperties.setTestOnBorrow(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_TESTONRETURN);
- if (value != null) {
- poolProperties.setTestOnReturn(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_TESTONCONNECT);
- if (value != null) {
- poolProperties.setTestOnConnect(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_TIMEBETWEENEVICTIONRUNSMILLIS);
- if (value != null) {
- poolProperties.setTimeBetweenEvictionRunsMillis(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_NUMTESTSPEREVICTIONRUN);
- if (value != null) {
- poolProperties.setNumTestsPerEvictionRun(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_MINEVICTABLEIDLETIMEMILLIS);
- if (value != null) {
- poolProperties.setMinEvictableIdleTimeMillis(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_TESTWHILEIDLE);
- if (value != null) {
- poolProperties.setTestWhileIdle(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_PASSWORD);
- if (value != null) {
- poolProperties.setPassword(value);
- }
-
- value = properties.getProperty(PROP_URL);
- if (value != null) {
- poolProperties.setUrl(value);
- }
-
- value = properties.getProperty(PROP_USERNAME);
- if (value != null) {
- poolProperties.setUsername(value);
- }
-
- value = properties.getProperty(PROP_VALIDATIONQUERY);
- if (value != null) {
- poolProperties.setValidationQuery(value);
- }
-
- value = properties.getProperty(PROP_VALIDATIONQUERY_TIMEOUT);
- if (value != null) {
- poolProperties.setValidationQueryTimeout(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_VALIDATOR_CLASS_NAME);
- if (value != null) {
- poolProperties.setValidatorClassName(value);
- }
-
- value = properties.getProperty(PROP_VALIDATIONINTERVAL);
- if (value != null) {
- poolProperties.setValidationInterval(Long.parseLong(value));
- }
-
- value = properties.getProperty(PROP_ACCESSTOUNDERLYINGCONNECTIONALLOWED);
- if (value != null) {
- poolProperties.setAccessToUnderlyingConnectionAllowed(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_REMOVEABANDONED);
- if (value != null) {
- poolProperties.setRemoveAbandoned(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_REMOVEABANDONEDTIMEOUT);
- if (value != null) {
- poolProperties.setRemoveAbandonedTimeout(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_LOGABANDONED);
- if (value != null) {
- poolProperties.setLogAbandoned(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_POOLPREPAREDSTATEMENTS);
- if (value != null) {
- log.warn(PROP_POOLPREPAREDSTATEMENTS + " is not a valid setting, it will have no effect.");
- }
-
- value = properties.getProperty(PROP_MAXOPENPREPAREDSTATEMENTS);
- if (value != null) {
- log.warn(PROP_MAXOPENPREPAREDSTATEMENTS + " is not a valid setting, it will have no effect.");
- }
-
- value = properties.getProperty(PROP_CONNECTIONPROPERTIES);
- if (value != null) {
- Properties p = getProperties(value);
- poolProperties.setDbProperties(p);
- } else {
- poolProperties.setDbProperties(new Properties());
- }
-
- if (poolProperties.getUsername()!=null) {
- poolProperties.getDbProperties().setProperty("user",poolProperties.getUsername());
- }
- if (poolProperties.getPassword()!=null) {
- poolProperties.getDbProperties().setProperty("password",poolProperties.getPassword());
- }
-
- value = properties.getProperty(PROP_INITSQL);
- if (value != null) {
- poolProperties.setInitSQL(value);
- }
-
- value = properties.getProperty(PROP_INTERCEPTORS);
- if (value != null) {
- poolProperties.setJdbcInterceptors(value);
- }
-
- value = properties.getProperty(PROP_JMX_ENABLED);
- if (value != null) {
- poolProperties.setJmxEnabled(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_FAIR_QUEUE);
- if (value != null) {
- poolProperties.setFairQueue(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_USE_EQUALS);
- if (value != null) {
- poolProperties.setUseEquals(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(OBJECT_NAME);
- if (value != null) {
- poolProperties.setName(ObjectName.quote(value));
- }
-
- value = properties.getProperty(PROP_ABANDONWHENPERCENTAGEFULL);
- if (value != null) {
- poolProperties.setAbandonWhenPercentageFull(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_MAXAGE);
- if (value != null) {
- poolProperties.setMaxAge(Long.parseLong(value));
- }
-
- value = properties.getProperty(PROP_USE_CON_LOCK);
- if (value != null) {
- poolProperties.setUseLock(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_DATASOURCE);
- if (value != null) {
- //this should never happen
- throw new IllegalArgumentException("Can't set dataSource property as a string, this must be a javax.sql.DataSource object.");
-
- }
-
- value = properties.getProperty(PROP_DATASOURCE_JNDI);
- if (value != null) {
- poolProperties.setDataSourceJNDI(value);
- }
-
- value = properties.getProperty(PROP_SUSPECT_TIMEOUT);
- if (value != null) {
- poolProperties.setSuspectTimeout(Integer.parseInt(value));
- }
-
- value = properties.getProperty(PROP_ALTERNATE_USERNAME_ALLOWED);
- if (value != null) {
- poolProperties.setAlternateUsernameAllowed(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_COMMITONRETURN);
- if (value != null) {
- poolProperties.setCommitOnReturn(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_ROLLBACKONRETURN);
- if (value != null) {
- poolProperties.setRollbackOnReturn(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_USEDISPOSABLECONNECTIONFACADE);
- if (value != null) {
- poolProperties.setUseDisposableConnectionFacade(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_LOGVALIDATIONERRORS);
- if (value != null) {
- poolProperties.setLogValidationErrors(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_PROPAGATEINTERRUPTSTATE);
- if (value != null) {
- poolProperties.setPropagateInterruptState(Boolean.parseBoolean(value));
- }
-
- value = properties.getProperty(PROP_IGNOREEXCEPTIONONPRELOAD);
- if (value != null) {
- poolProperties.setIgnoreExceptionOnPreLoad(Boolean.parseBoolean(value));
- }
-
- return poolProperties;
- }
-
- /**
- * Creates and configures a {@link DataSource} instance based on the
- * given properties.
- *
- * @param properties the datasource configuration properties
- * @return the datasource
- * @throws Exception if an error occurs creating the data source
- */
- public DataSource createDataSource(Properties properties) throws Exception {
- return createDataSource(properties,null,false);
- }
- public DataSource createDataSource(Properties properties,Context context, boolean XA) throws Exception {
- PoolConfiguration poolProperties = DataSourceFactory.parsePoolProperties(properties);
- if (poolProperties.getDataSourceJNDI()!=null && poolProperties.getDataSource()==null) {
- performJNDILookup(context, poolProperties);
- }
- org.apache.tomcat.jdbc.pool.DataSource dataSource = XA?
- new org.apache.tomcat.jdbc.pool.XADataSource(poolProperties) :
- new org.apache.tomcat.jdbc.pool.DataSource(poolProperties);
- //initialise the pool itself
- dataSource.createPool();
- // Return the configured DataSource instance
- return dataSource;
- }
-
- public void performJNDILookup(Context context, PoolConfiguration poolProperties) {
- Object jndiDS = null;
- try {
- if (context!=null) {
- jndiDS = context.lookup(poolProperties.getDataSourceJNDI());
- } else {
- log.warn("dataSourceJNDI property is configured, but local JNDI context is null.");
- }
- } catch (NamingException e) {
- log.debug("The name \""+poolProperties.getDataSourceJNDI()+"\" cannot be found in the local context.");
- }
- if (jndiDS==null) {
- try {
- context = new InitialContext();
- jndiDS = context.lookup(poolProperties.getDataSourceJNDI());
- } catch (NamingException e) {
- log.warn("The name \""+poolProperties.getDataSourceJNDI()+"\" cannot be found in the InitialContext.");
- }
- }
- if (jndiDS!=null) {
- poolProperties.setDataSource(jndiDS);
- }
- }
-
- /**
- * Parse properties from the string. Format of the string must be [propertyName=property;]*.
- * @param propText The properties string
- * @return the properties
- */
- protected static Properties getProperties(String propText) {
- return PoolProperties.getProperties(propText,null);
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.io.PrintWriter;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.sql.SQLFeatureNotSupportedException;
-import java.util.Iterator;
-import java.util.Properties;
-import java.util.concurrent.Future;
-import java.util.logging.Logger;
-
-import javax.sql.XAConnection;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.PoolProperties.InterceptorDefinition;
-
-/**
- *
- * The DataSource proxy lets us implements methods that don't exist in the current
- * compiler JDK but might be methods that are part of a future JDK DataSource interface.
- * <br>
- * It's a trick to work around compiler issues when implementing interfaces. For example,
- * I could put in Java 6 methods of javax.sql.DataSource here, and compile it with JDK 1.5
- * and still be able to run under Java 6 without getting NoSuchMethodException.
- *
- * @version 1.0
- */
-
-public class DataSourceProxy implements PoolConfiguration {
- private static final Log log = LogFactory.getLog(DataSourceProxy.class);
-
- protected volatile ConnectionPool pool = null;
-
- protected volatile PoolConfiguration poolProperties = null;
-
- public DataSourceProxy() {
- this(new PoolProperties());
- }
-
- public DataSourceProxy(PoolConfiguration poolProperties) {
- if (poolProperties == null) throw new NullPointerException("PoolConfiguration cannot be null.");
- this.poolProperties = poolProperties;
- }
-
-
- @SuppressWarnings("unused") // Has to match signature in DataSource
- public boolean isWrapperFor(Class<?> iface) throws SQLException {
- // we are not a wrapper of anything
- return false;
- }
-
-
- @SuppressWarnings("unused") // Has to match signature in DataSource
- public <T> T unwrap(Class<T> iface) throws SQLException {
- //we can't unwrap anything
- return null;
- }
-
- /**
- * Get a database connection.
- * {@link javax.sql.DataSource#getConnection()}
- * @param username The user name
- * @param password The password
- * @return the connection
- * @throws SQLException Connection error
- */
- public Connection getConnection(String username, String password) throws SQLException {
- if (this.getPoolProperties().isAlternateUsernameAllowed()) {
- if (pool == null)
- return createPool().getConnection(username,password);
- return pool.getConnection(username,password);
- } else {
- return getConnection();
- }
- }
-
- public PoolConfiguration getPoolProperties() {
- return poolProperties;
- }
-
- /**
- * Sets up the connection pool, by creating a pooling driver.
- * @return the connection pool
- * @throws SQLException Error creating pool
- */
- public ConnectionPool createPool() throws SQLException {
- if (pool != null) {
- return pool;
- } else {
- return pCreatePool();
- }
- }
-
- /**
- * Sets up the connection pool, by creating a pooling driver.
- */
- private synchronized ConnectionPool pCreatePool() throws SQLException {
- if (pool != null) {
- return pool;
- } else {
- pool = new ConnectionPool(poolProperties);
- return pool;
- }
- }
-
- /**
- * Get a database connection.
- * {@link javax.sql.DataSource#getConnection()}
- * @return the connection
- * @throws SQLException Connection error
- */
- public Connection getConnection() throws SQLException {
- if (pool == null)
- return createPool().getConnection();
- return pool.getConnection();
- }
-
- /**
- * Invokes an sync operation to retrieve the connection.
- * @return a Future containing a reference to the connection when it becomes available
- * @throws SQLException Connection error
- */
- public Future<Connection> getConnectionAsync() throws SQLException {
- if (pool == null)
- return createPool().getConnectionAsync();
- return pool.getConnectionAsync();
- }
-
- /**
- * Get a database connection.
- * {@link javax.sql.XADataSource#getXAConnection()}
- * @return the connection
- * @throws SQLException Connection error
- */
- public XAConnection getXAConnection() throws SQLException {
- Connection con = getConnection();
- if (con instanceof XAConnection) {
- return (XAConnection)con;
- } else {
- try {
- con.close();
- } catch (Exception ignore) {
- // Ignore
- }
- throw new SQLException("Connection from pool does not implement javax.sql.XAConnection");
- }
- }
-
- /**
- * Get a database connection.
- * {@link javax.sql.XADataSource#getXAConnection(String, String)}
- * @param username The user name
- * @param password The password
- * @return the connection
- * @throws SQLException Connection error
- */
- public XAConnection getXAConnection(String username, String password) throws SQLException {
- Connection con = getConnection(username, password);
- if (con instanceof XAConnection) {
- return (XAConnection)con;
- } else {
- try {
- con.close();
- } catch (Exception ignore) {
- // Ignore
- }
- throw new SQLException("Connection from pool does not implement javax.sql.XAConnection");
- }
- }
-
-
- /**
- * Get a database connection.
- * {@link javax.sql.DataSource#getConnection()}
- * @return the connection
- * @throws SQLException Connection error
- */
- public javax.sql.PooledConnection getPooledConnection() throws SQLException {
- return (javax.sql.PooledConnection) getConnection();
- }
-
- /**
- * Get a database connection.
- * {@link javax.sql.DataSource#getConnection()}
- * @param username unused
- * @param password unused
- * @return the connection
- * @throws SQLException Connection error
- */
- public javax.sql.PooledConnection getPooledConnection(String username,
- String password) throws SQLException {
- return (javax.sql.PooledConnection) getConnection();
- }
-
- public ConnectionPool getPool() {
- try {
- return createPool();
- }catch (SQLException x) {
- log.error("Error during connection pool creation.", x);
- return null;
- }
- }
-
-
- public void close() {
- close(false);
- }
- public void close(boolean all) {
- try {
- if (pool != null) {
- final ConnectionPool p = pool;
- pool = null;
- if (p!=null) {
- p.close(all);
- }
- }
- }catch (Exception x) {
- log.warn("Error during connection pool closure.", x);
- }
- }
-
- public int getPoolSize() {
- final ConnectionPool p = pool;
- if (p == null) return 0;
- else return p.getSize();
- }
-
-
- @Override
- public String toString() {
- return super.toString()+"{"+getPoolProperties()+"}";
- }
-
-
-/*-----------------------------------------------------------------------*/
-// PROPERTIES WHEN NOT USED WITH FACTORY
-/*------------------------------------------------------------------------*/
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getPoolName() {
- return pool.getName();
- }
-
-
- public void setPoolProperties(PoolConfiguration poolProperties) {
- this.poolProperties = poolProperties;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDriverClassName(String driverClassName) {
- this.poolProperties.setDriverClassName(driverClassName);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setInitialSize(int initialSize) {
- this.poolProperties.setInitialSize(initialSize);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setInitSQL(String initSQL) {
- this.poolProperties.setInitSQL(initSQL);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setLogAbandoned(boolean logAbandoned) {
- this.poolProperties.setLogAbandoned(logAbandoned);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMaxActive(int maxActive) {
- this.poolProperties.setMaxActive(maxActive);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMaxIdle(int maxIdle) {
- this.poolProperties.setMaxIdle(maxIdle);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMaxWait(int maxWait) {
- this.poolProperties.setMaxWait(maxWait);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
- this.poolProperties.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMinIdle(int minIdle) {
- this.poolProperties.setMinIdle(minIdle);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {
- this.poolProperties.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setPassword(String password) {
- this.poolProperties.setPassword(password);
- this.poolProperties.getDbProperties().setProperty("password",this.poolProperties.getPassword());
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setRemoveAbandoned(boolean removeAbandoned) {
- this.poolProperties.setRemoveAbandoned(removeAbandoned);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setRemoveAbandonedTimeout(int removeAbandonedTimeout) {
- this.poolProperties.setRemoveAbandonedTimeout(removeAbandonedTimeout);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTestOnBorrow(boolean testOnBorrow) {
- this.poolProperties.setTestOnBorrow(testOnBorrow);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTestOnConnect(boolean testOnConnect) {
- this.poolProperties.setTestOnConnect(testOnConnect);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTestOnReturn(boolean testOnReturn) {
- this.poolProperties.setTestOnReturn(testOnReturn);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTestWhileIdle(boolean testWhileIdle) {
- this.poolProperties.setTestWhileIdle(testWhileIdle);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
- this.poolProperties.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setUrl(String url) {
- this.poolProperties.setUrl(url);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setUsername(String username) {
- this.poolProperties.setUsername(username);
- this.poolProperties.getDbProperties().setProperty("user",getPoolProperties().getUsername());
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setValidationInterval(long validationInterval) {
- this.poolProperties.setValidationInterval(validationInterval);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setValidationQuery(String validationQuery) {
- this.poolProperties.setValidationQuery(validationQuery);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setValidatorClassName(String className) {
- this.poolProperties.setValidatorClassName(className);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setValidationQueryTimeout(int validationQueryTimeout) {
- this.poolProperties.setValidationQueryTimeout(validationQueryTimeout);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setJdbcInterceptors(String interceptors) {
- this.getPoolProperties().setJdbcInterceptors(interceptors);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setJmxEnabled(boolean enabled) {
- this.getPoolProperties().setJmxEnabled(enabled);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setFairQueue(boolean fairQueue) {
- this.getPoolProperties().setFairQueue(fairQueue);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setUseLock(boolean useLock) {
- this.getPoolProperties().setUseLock(useLock);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDefaultCatalog(String catalog) {
- this.getPoolProperties().setDefaultCatalog(catalog);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDefaultAutoCommit(Boolean autocommit) {
- this.getPoolProperties().setDefaultAutoCommit(autocommit);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDefaultTransactionIsolation(int defaultTransactionIsolation) {
- this.getPoolProperties().setDefaultTransactionIsolation(defaultTransactionIsolation);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setConnectionProperties(String properties) {
- try {
- java.util.Properties prop = DataSourceFactory
- .getProperties(properties);
- Iterator<?> i = prop.keySet().iterator();
- while (i.hasNext()) {
- String key = (String) i.next();
- String value = prop.getProperty(key);
- getPoolProperties().getDbProperties().setProperty(key, value);
- }
-
- } catch (Exception x) {
- log.error("Unable to parse connection properties.", x);
- throw new RuntimeException(x);
- }
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setUseEquals(boolean useEquals) {
- this.getPoolProperties().setUseEquals(useEquals);
- }
-
- /**
- * no-op
- * {@link javax.sql.DataSource#getParentLogger}
- * @return no return value
- * @throws SQLFeatureNotSupportedException Unsupported
- */
- public Logger getParentLogger() throws SQLFeatureNotSupportedException {
- throw new SQLFeatureNotSupportedException();
- }
-
- /**
- * no-op
- * {@link javax.sql.DataSource#getLogWriter}
- * @return null
- * @throws SQLException No exception
- */
- public PrintWriter getLogWriter() throws SQLException {
- return null;
- }
-
-
- /**
- * no-op
- * {@link javax.sql.DataSource#setLogWriter(PrintWriter)}
- * @param out Ignored
- * @throws SQLException No exception
- */
- public void setLogWriter(PrintWriter out) throws SQLException {
- // NOOP
- }
-
- /**
- * no-op
- * {@link javax.sql.DataSource#getLoginTimeout}
- * @return the timeout
- */
- public int getLoginTimeout() {
- if (poolProperties == null) {
- return 0;
- } else {
- return poolProperties.getMaxWait() / 1000;
- }
- }
-
- /**
- * {@link javax.sql.DataSource#setLoginTimeout(int)}
- * @param i The timeout value
- */
- public void setLoginTimeout(int i) {
- if (poolProperties == null) {
- return;
- } else {
- poolProperties.setMaxWait(1000 * i);
- }
-
- }
-
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getSuspectTimeout() {
- return getPoolProperties().getSuspectTimeout();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setSuspectTimeout(int seconds) {
- getPoolProperties().setSuspectTimeout(seconds);
- }
-
- //===============================================================================
-// Expose JMX attributes through Tomcat's dynamic reflection
-//===============================================================================
- /**
- * If the pool has not been created, it will be created during this call.
- * @return the number of established but idle connections
- */
- public int getIdle() {
- try {
- return createPool().getIdle();
- }catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * {@link #getIdle()}
- * @return the number of established but idle connections
- */
- public int getNumIdle() {
- return getIdle();
- }
-
- /**
- * Forces an abandon check on the connection pool.
- * If connections that have been abandoned exists, they will be closed during this run
- */
- public void checkAbandoned() {
- try {
- createPool().checkAbandoned();
- }catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * Forces a check for resizing of the idle connections
- */
- public void checkIdle() {
- try {
- createPool().checkIdle();
- }catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * @return number of connections in use by the application
- */
- public int getActive() {
- try {
- return createPool().getActive();
- }catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * @return number of connections in use by the application
- * {@link DataSource#getActive()}
- */
- public int getNumActive() {
- return getActive();
- }
-
- /**
- * @return number of threads waiting for a connection
- */
- public int getWaitCount() {
- try {
- return createPool().getWaitCount();
- }catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * @return the current size of the pool
- */
- public int getSize() {
- try {
- return createPool().getSize();
- }catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * Performs a validation on idle connections
- */
- public void testIdle() {
- try {
- createPool().testAllIdle();
- }catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * The total number of connections borrowed from this pool.
- * @return the borrowed connection count
- */
- public long getBorrowedCount() {
- try {
- return createPool().getBorrowedCount();
- } catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * The total number of connections returned to this pool.
- * @return the returned connection count
- */
- public long getReturnedCount() {
- try {
- return createPool().getReturnedCount();
- } catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * The total number of connections created by this pool.
- * @return the created connection count
- */
- public long getCreatedCount() {
- try {
- return createPool().getCreatedCount();
- } catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * The total number of connections released from this pool.
- * @return the released connection count
- */
- public long getReleasedCount() {
- try {
- return createPool().getReleasedCount();
- } catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * The total number of connections reconnected by this pool.
- * @return the reconnected connection count
- */
- public long getReconnectedCount() {
- try {
- return createPool().getReconnectedCount();
- } catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * The total number of connections released by remove abandoned.
- * @return the PoolCleaner removed abandoned connection count
- */
- public long getRemoveAbandonedCount() {
- try {
- return createPool().getRemoveAbandonedCount();
- } catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * The total number of connections released by eviction.
- * @return the PoolCleaner evicted idle connection count
- */
- public long getReleasedIdleCount() {
- try {
- return createPool().getReleasedIdleCount();
- } catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- /**
- * reset the statistics of this pool.
- */
- public void resetStats() {
- try {
- createPool().resetStats();
- } catch (SQLException x) {
- throw new RuntimeException(x);
- }
- }
-
- //=========================================================
- // PROPERTIES / CONFIGURATION
- //=========================================================
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getConnectionProperties() {
- return getPoolProperties().getConnectionProperties();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Properties getDbProperties() {
- return getPoolProperties().getDbProperties();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getDefaultCatalog() {
- return getPoolProperties().getDefaultCatalog();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getDefaultTransactionIsolation() {
- return getPoolProperties().getDefaultTransactionIsolation();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getDriverClassName() {
- return getPoolProperties().getDriverClassName();
- }
-
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getInitialSize() {
- return getPoolProperties().getInitialSize();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getInitSQL() {
- return getPoolProperties().getInitSQL();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getJdbcInterceptors() {
- return getPoolProperties().getJdbcInterceptors();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMaxActive() {
- return getPoolProperties().getMaxActive();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMaxIdle() {
- return getPoolProperties().getMaxIdle();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMaxWait() {
- return getPoolProperties().getMaxWait();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMinEvictableIdleTimeMillis() {
- return getPoolProperties().getMinEvictableIdleTimeMillis();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMinIdle() {
- return getPoolProperties().getMinIdle();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public long getMaxAge() {
- return getPoolProperties().getMaxAge();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getName() {
- return getPoolProperties().getName();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getNumTestsPerEvictionRun() {
- return getPoolProperties().getNumTestsPerEvictionRun();
- }
-
- /**
- * @return DOES NOT RETURN THE PASSWORD, IT WOULD SHOW UP IN JMX
- */
- @Override
- public String getPassword() {
- return "Password not available as DataSource/JMX operation.";
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getRemoveAbandonedTimeout() {
- return getPoolProperties().getRemoveAbandonedTimeout();
- }
-
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getTimeBetweenEvictionRunsMillis() {
- return getPoolProperties().getTimeBetweenEvictionRunsMillis();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getUrl() {
- return getPoolProperties().getUrl();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getUsername() {
- return getPoolProperties().getUsername();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public long getValidationInterval() {
- return getPoolProperties().getValidationInterval();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getValidationQuery() {
- return getPoolProperties().getValidationQuery();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getValidationQueryTimeout() {
- return getPoolProperties().getValidationQueryTimeout();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getValidatorClassName() {
- return getPoolProperties().getValidatorClassName();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Validator getValidator() {
- return getPoolProperties().getValidator();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setValidator(Validator validator) {
- getPoolProperties().setValidator(validator);
- }
-
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isAccessToUnderlyingConnectionAllowed() {
- return getPoolProperties().isAccessToUnderlyingConnectionAllowed();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Boolean isDefaultAutoCommit() {
- return getPoolProperties().isDefaultAutoCommit();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Boolean isDefaultReadOnly() {
- return getPoolProperties().isDefaultReadOnly();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isLogAbandoned() {
- return getPoolProperties().isLogAbandoned();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isPoolSweeperEnabled() {
- return getPoolProperties().isPoolSweeperEnabled();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isRemoveAbandoned() {
- return getPoolProperties().isRemoveAbandoned();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getAbandonWhenPercentageFull() {
- return getPoolProperties().getAbandonWhenPercentageFull();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isTestOnBorrow() {
- return getPoolProperties().isTestOnBorrow();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isTestOnConnect() {
- return getPoolProperties().isTestOnConnect();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isTestOnReturn() {
- return getPoolProperties().isTestOnReturn();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isTestWhileIdle() {
- return getPoolProperties().isTestWhileIdle();
- }
-
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Boolean getDefaultAutoCommit() {
- return getPoolProperties().getDefaultAutoCommit();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Boolean getDefaultReadOnly() {
- return getPoolProperties().getDefaultReadOnly();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public InterceptorDefinition[] getJdbcInterceptorsAsArray() {
- return getPoolProperties().getJdbcInterceptorsAsArray();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean getUseLock() {
- return getPoolProperties().getUseLock();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isFairQueue() {
- return getPoolProperties().isFairQueue();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isJmxEnabled() {
- return getPoolProperties().isJmxEnabled();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isUseEquals() {
- return getPoolProperties().isUseEquals();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setAbandonWhenPercentageFull(int percentage) {
- getPoolProperties().setAbandonWhenPercentageFull(percentage);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setAccessToUnderlyingConnectionAllowed(boolean accessToUnderlyingConnectionAllowed) {
- getPoolProperties().setAccessToUnderlyingConnectionAllowed(accessToUnderlyingConnectionAllowed);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDbProperties(Properties dbProperties) {
- getPoolProperties().setDbProperties(dbProperties);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDefaultReadOnly(Boolean defaultReadOnly) {
- getPoolProperties().setDefaultReadOnly(defaultReadOnly);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMaxAge(long maxAge) {
- getPoolProperties().setMaxAge(maxAge);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setName(String name) {
- getPoolProperties().setName(name);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setDataSource(Object ds) {
- getPoolProperties().setDataSource(ds);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Object getDataSource() {
- return getPoolProperties().getDataSource();
- }
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setDataSourceJNDI(String jndiDS) {
- getPoolProperties().setDataSourceJNDI(jndiDS);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public String getDataSourceJNDI() {
- return getPoolProperties().getDataSourceJNDI();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isAlternateUsernameAllowed() {
- return getPoolProperties().isAlternateUsernameAllowed();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setAlternateUsernameAllowed(boolean alternateUsernameAllowed) {
- getPoolProperties().setAlternateUsernameAllowed(alternateUsernameAllowed);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setCommitOnReturn(boolean commitOnReturn) {
- getPoolProperties().setCommitOnReturn(commitOnReturn);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getCommitOnReturn() {
- return getPoolProperties().getCommitOnReturn();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setRollbackOnReturn(boolean rollbackOnReturn) {
- getPoolProperties().setRollbackOnReturn(rollbackOnReturn);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getRollbackOnReturn() {
- return getPoolProperties().getRollbackOnReturn();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setUseDisposableConnectionFacade(boolean useDisposableConnectionFacade) {
- getPoolProperties().setUseDisposableConnectionFacade(useDisposableConnectionFacade);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getUseDisposableConnectionFacade() {
- return getPoolProperties().getUseDisposableConnectionFacade();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setLogValidationErrors(boolean logValidationErrors) {
- getPoolProperties().setLogValidationErrors(logValidationErrors);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getLogValidationErrors() {
- return getPoolProperties().getLogValidationErrors();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getPropagateInterruptState() {
- return getPoolProperties().getPropagateInterruptState();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setPropagateInterruptState(boolean propagateInterruptState) {
- getPoolProperties().setPropagateInterruptState(propagateInterruptState);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isIgnoreExceptionOnPreLoad() {
- return getPoolProperties().isIgnoreExceptionOnPreLoad();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setIgnoreExceptionOnPreLoad(boolean ignoreExceptionOnPreLoad) {
- getPoolProperties().setIgnoreExceptionOnPreLoad(ignoreExceptionOnPreLoad);
- }
-
- public void purge() {
- try {
- createPool().purge();
- }catch (SQLException x) {
- log.error("Unable to purge pool.",x);
- }
- }
-
- public void purgeOnReturn() {
- try {
- createPool().purgeOnReturn();
- }catch (SQLException x) {
- log.error("Unable to purge pool.",x);
- }
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.sql.SQLException;
-
-/**
- * A DisposableConnectionFacade object is the top most interceptor that wraps an
- * object of type {@link PooledConnection}. The ProxyCutOffConnection intercepts
- * two methods:
- * <ul>
- * <li>{@link java.sql.Connection#close()} - returns the connection to the
- * pool then breaks the link between cutoff and the next interceptor.
- * May be called multiple times.</li>
- * <li>{@link java.lang.Object#toString()} - returns a custom string for this
- * object</li>
- * </ul>
- * By default method comparisons is done on a String reference level, unless the
- * {@link PoolConfiguration#setUseEquals(boolean)} has been called with a
- * <code>true</code> argument.
- */
-public class DisposableConnectionFacade extends JdbcInterceptor {
- protected DisposableConnectionFacade(JdbcInterceptor interceptor) {
- setUseEquals(interceptor.isUseEquals());
- setNext(interceptor);
- }
-
- @Override
- public void reset(ConnectionPool parent, PooledConnection con) {
- }
-
-
-
- @Override
- public int hashCode() {
- return System.identityHashCode(this);
- }
-
- @Override
- public boolean equals(Object obj) {
- return this==obj;
- }
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args)
- throws Throwable {
- if (compare(EQUALS_VAL, method)) {
- return Boolean.valueOf(
- this.equals(Proxy.getInvocationHandler(args[0])));
- } else if (compare(HASHCODE_VAL, method)) {
- return Integer.valueOf(this.hashCode());
- } else if (getNext()==null) {
- if (compare(ISCLOSED_VAL, method)) {
- return Boolean.TRUE;
- }
- else if (compare(CLOSE_VAL, method)) {
- return null;
- }
- else if (compare(ISVALID_VAL, method)) {
- return Boolean.FALSE;
- }
- }
-
- try {
- return super.invoke(proxy, method, args);
- } catch (NullPointerException e) {
- if (getNext() == null) {
- if (compare(TOSTRING_VAL, method)) {
- return "DisposableConnectionFacade[null]";
- }
- throw new SQLException(
- "PooledConnection has already been closed.");
- }
-
- throw e;
- } finally {
- if (compare(CLOSE_VAL, method)) {
- setNext(null);
- }
- }
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.NoSuchElementException;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- *
- * A simple implementation of a blocking queue with fairness waiting.
- * invocations to method poll(...) will get handed out in the order they were received.
- * Locking is fine grained, a shared lock is only used during the first level of contention, waiting is done in a
- * lock per thread basis so that order is guaranteed once the thread goes into a suspended monitor state.
- * <br>
- * Not all of the methods of the {@link java.util.concurrent.BlockingQueue} are implemented.
- *
- * @param <E> Type of element in the queue
- */
-
-public class FairBlockingQueue<E> implements BlockingQueue<E> {
-
- /**
- * This little sucker is used to reorder the way to do
- * {@link java.util.concurrent.locks.Lock#lock()},
- * {@link java.util.concurrent.locks.Lock#unlock()}
- * and
- * {@link java.util.concurrent.CountDownLatch#countDown()}
- * during the {@link #poll(long, TimeUnit)} operation.
- * On Linux, it performs much better if we count down while we hold the global
- * lock, on Solaris its the other way around.
- * Until we have tested other platforms we only check for Linux.
- */
- static final boolean isLinux = "Linux".equals(System.getProperty("os.name")) &&
- (!Boolean.getBoolean(FairBlockingQueue.class.getName()+".ignoreOS"));
-
- /**
- * Phase one entry lock in order to give out
- * per-thread-locks for the waiting phase we have
- * a phase one lock during the contention period.
- */
- final ReentrantLock lock = new ReentrantLock(false);
-
- /**
- * All the objects in the pool are stored in a simple linked list
- */
- final LinkedList<E> items;
-
- /**
- * All threads waiting for an object are stored in a linked list
- */
- final LinkedList<ExchangeCountDownLatch<E>> waiters;
-
- /**
- * Creates a new fair blocking queue.
- */
- public FairBlockingQueue() {
- items = new LinkedList<>();
- waiters = new LinkedList<>();
- }
-
- //------------------------------------------------------------------
- // USED BY CONPOOL IMPLEMENTATION
- //------------------------------------------------------------------
- /**
- * Will always return true, queue is unbounded.
- * {@inheritDoc}
- */
- @Override
- public boolean offer(E e) {
- //during the offer, we will grab the main lock
- final ReentrantLock lock = this.lock;
- lock.lock();
- ExchangeCountDownLatch<E> c = null;
- try {
- //check to see if threads are waiting for an object
- if (waiters.size() > 0) {
- //if threads are waiting grab the latch for that thread
- c = waiters.poll();
- //give the object to the thread instead of adding it to the pool
- c.setItem(e);
- if (isLinux) c.countDown();
- } else {
- //we always add first, so that the most recently used object will be given out
- items.addFirst(e);
- }
- } finally {
- lock.unlock();
- }
- //if we exchanged an object with another thread, wake it up.
- if (!isLinux && c!=null) c.countDown();
- //we have an unbounded queue, so always return true
- return true;
- }
-
- /**
- * Will never timeout, as it invokes the {@link #offer(Object)} method.
- * Once a lock has been acquired, the
- * {@inheritDoc}
- */
- @Override
- public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
- return offer(e);
- }
-
- /**
- * Fair retrieval of an object in the queue.
- * Objects are returned in the order the threads requested them.
- * {@inheritDoc}
- */
- @Override
- public E poll(long timeout, TimeUnit unit) throws InterruptedException {
- E result = null;
- final ReentrantLock lock = this.lock;
- //acquire the global lock until we know what to do
- lock.lock();
- try {
- //check to see if we have objects
- result = items.poll();
- if (result==null && timeout>0) {
- //the queue is empty we will wait for an object
- ExchangeCountDownLatch<E> c = new ExchangeCountDownLatch<>(1);
- //add to the bottom of the wait list
- waiters.addLast(c);
- //unlock the global lock
- lock.unlock();
- boolean didtimeout = true;
- InterruptedException interruptedException = null;
- try {
- //wait for the specified timeout
- didtimeout = !c.await(timeout, unit);
- } catch (InterruptedException ix) {
- interruptedException = ix;
- }
- if (didtimeout) {
- //if we timed out, or got interrupted
- // remove ourselves from the waitlist
- lock.lock();
- try {
- waiters.remove(c);
- } finally {
- lock.unlock();
- }
- }
- //return the item we received, can be null if we timed out
- result = c.getItem();
- if (null!=interruptedException) {
- //we got interrupted
- if ( null!=result) {
- //we got a result - clear the interrupt status
- //don't propagate cause we have removed a connection from pool
- Thread.interrupted();
- } else {
- throw interruptedException;
- }
- }
- } else {
- //we have an object, release
- lock.unlock();
- }
- } finally {
- if (lock.isHeldByCurrentThread()) {
- lock.unlock();
- }
- }
- return result;
- }
-
- /**
- * Request an item from the queue asynchronously
- * @return - a future pending the result from the queue poll request
- */
- public Future<E> pollAsync() {
- Future<E> result = null;
- final ReentrantLock lock = this.lock;
- //grab the global lock
- lock.lock();
- try {
- //check to see if we have objects in the queue
- E item = items.poll();
- if (item==null) {
- //queue is empty, add ourselves as waiters
- ExchangeCountDownLatch<E> c = new ExchangeCountDownLatch<>(1);
- waiters.addLast(c);
- //return a future that will wait for the object
- result = new ItemFuture<>(c);
- } else {
- //return a future with the item
- result = new ItemFuture<>(item);
- }
- } finally {
- lock.unlock();
- }
- return result;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean remove(Object e) {
- final ReentrantLock lock = this.lock;
- lock.lock();
- try {
- return items.remove(e);
- } finally {
- lock.unlock();
- }
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int size() {
- return items.size();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Iterator<E> iterator() {
- return new FairIterator();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public E poll() {
- final ReentrantLock lock = this.lock;
- lock.lock();
- try {
- return items.poll();
- } finally {
- lock.unlock();
- }
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean contains(Object e) {
- final ReentrantLock lock = this.lock;
- lock.lock();
- try {
- return items.contains(e);
- } finally {
- lock.unlock();
- }
- }
-
-
- //------------------------------------------------------------------
- // NOT USED BY CONPOOL IMPLEMENTATION
- //------------------------------------------------------------------
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean add(E e) {
- return offer(e);
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public int drainTo(Collection<? super E> c, int maxElements) {
- throw new UnsupportedOperationException("int drainTo(Collection<? super E> c, int maxElements)");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
-
- @Override
- public int drainTo(Collection<? super E> c) {
- return drainTo(c,Integer.MAX_VALUE);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void put(E e) throws InterruptedException {
- offer(e);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int remainingCapacity() {
- return Integer.MAX_VALUE - size();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public E take() throws InterruptedException {
- return this.poll(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean addAll(Collection<? extends E> c) {
- Iterator<? extends E> i = c.iterator();
- while (i.hasNext()) {
- E e = i.next();
- offer(e);
- }
- return true;
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public void clear() {
- throw new UnsupportedOperationException("void clear()");
-
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public boolean containsAll(Collection<?> c) {
- throw new UnsupportedOperationException("boolean containsAll(Collection<?> c)");
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isEmpty() {
- return size() == 0;
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public boolean removeAll(Collection<?> c) {
- throw new UnsupportedOperationException("boolean removeAll(Collection<?> c)");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public boolean retainAll(Collection<?> c) {
- throw new UnsupportedOperationException("boolean retainAll(Collection<?> c)");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public Object[] toArray() {
- throw new UnsupportedOperationException("Object[] toArray()");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public <T> T[] toArray(T[] a) {
- throw new UnsupportedOperationException("<T> T[] toArray(T[] a)");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public E element() {
- throw new UnsupportedOperationException("E element()");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public E peek() {
- throw new UnsupportedOperationException("E peek()");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public E remove() {
- throw new UnsupportedOperationException("E remove()");
- }
-
-
-
- //------------------------------------------------------------------
- // Non cancellable Future used to check and see if a connection has been made available
- //------------------------------------------------------------------
- protected class ItemFuture<T> implements Future<T> {
- protected volatile T item = null;
- protected volatile ExchangeCountDownLatch<T> latch = null;
- protected volatile boolean canceled = false;
-
- public ItemFuture(T item) {
- this.item = item;
- }
-
- public ItemFuture(ExchangeCountDownLatch<T> latch) {
- this.latch = latch;
- }
-
- @Override
- public boolean cancel(boolean mayInterruptIfRunning) {
- return false; //don't allow cancel for now
- }
-
- @Override
- public T get() throws InterruptedException, ExecutionException {
- if (item!=null) {
- return item;
- } else if (latch!=null) {
- latch.await();
- return latch.getItem();
- } else {
- throw new ExecutionException("ItemFuture incorrectly instantiated. Bug in the code?", new Exception());
- }
- }
-
- @Override
- public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
- if (item!=null) {
- return item;
- } else if (latch!=null) {
- boolean timedout = !latch.await(timeout, unit);
- if (timedout) throw new TimeoutException();
- else return latch.getItem();
- } else {
- throw new ExecutionException("ItemFuture incorrectly instantiated. Bug in the code?", new Exception());
- }
- }
-
- @Override
- public boolean isCancelled() {
- return false;
- }
-
- @Override
- public boolean isDone() {
- return (item!=null || latch.getItem()!=null);
- }
-
- }
-
- //------------------------------------------------------------------
- // Count down latch that can be used to exchange information
- //------------------------------------------------------------------
- protected class ExchangeCountDownLatch<T> extends CountDownLatch {
- protected volatile T item;
- public ExchangeCountDownLatch(int i) {
- super(i);
- }
- public T getItem() {
- return item;
- }
- public void setItem(T item) {
- this.item = item;
- }
- }
-
- //------------------------------------------------------------------
- // Iterator safe from concurrent modification exceptions
- //------------------------------------------------------------------
- protected class FairIterator implements Iterator<E> {
- E[] elements = null;
- int index;
- E element = null;
-
- @SuppressWarnings("unchecked") // Can't create arrays of generic types
- public FairIterator() {
- final ReentrantLock lock = FairBlockingQueue.this.lock;
- lock.lock();
- try {
- elements = (E[]) new Object[FairBlockingQueue.this.items.size()];
- FairBlockingQueue.this.items.toArray(elements);
- index = 0;
- } finally {
- lock.unlock();
- }
- }
- @Override
- public boolean hasNext() {
- return index<elements.length;
- }
-
- @Override
- public E next() {
- if (!hasNext()) {
- throw new NoSuchElementException();
- }
- element = elements[index++];
- return element;
- }
-
- @Override
- public void remove() {
- final ReentrantLock lock = FairBlockingQueue.this.lock;
- lock.lock();
- try {
- if (element!=null) {
- FairBlockingQueue.this.items.remove(element);
- }
- } finally {
- lock.unlock();
- }
- }
-
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.util.Map;
-
-import org.apache.tomcat.jdbc.pool.PoolProperties.InterceptorProperty;
-
-/**
- * Abstract class that is to be extended for implementations of interceptors.
- * Everytime an operation is called on the {@link java.sql.Connection} object the
- * {@link #invoke(Object, Method, Object[])} method on the interceptor will be called.
- * Interceptors are useful to change or improve behavior of the connection pool.<br>
- * Interceptors can receive a set of properties. Each sub class is responsible for parsing the properties during runtime when they
- * are needed or simply override the {@link #setProperties(Map)} method.
- * Properties arrive in a key-value pair of Strings as they were received through the configuration.
- * This method is called once per cached connection object when the object is first configured.
- *
- * @version 1.0
- */
-public abstract class JdbcInterceptor implements InvocationHandler {
- /**
- * {@link java.sql.Connection#close()} method name
- */
- public static final String CLOSE_VAL = "close";
- /**
- * {@link Object#toString()} method name
- */
- public static final String TOSTRING_VAL = "toString";
- /**
- * {@link java.sql.Connection#isClosed()} method name
- */
- public static final String ISCLOSED_VAL = "isClosed";
- /**
- * {@link javax.sql.PooledConnection#getConnection()} method name
- */
- public static final String GETCONNECTION_VAL = "getConnection";
- /**
- * {@link java.sql.Wrapper#unwrap(Class)} method name
- */
- public static final String UNWRAP_VAL = "unwrap";
- /**
- * {@link java.sql.Wrapper#isWrapperFor(Class)} method name
- */
- public static final String ISWRAPPERFOR_VAL = "isWrapperFor";
-
- /**
- * {@link java.sql.Connection#isValid(int)} method name
- */
- public static final String ISVALID_VAL = "isValid";
-
- /**
- * {@link java.lang.Object#equals(Object)}
- */
- public static final String EQUALS_VAL = "equals";
-
- /**
- * {@link java.lang.Object#hashCode()}
- */
- public static final String HASHCODE_VAL = "hashCode";
-
- /**
- * Properties for this interceptor.
- */
- protected Map<String,InterceptorProperty> properties = null;
-
- /**
- * The next interceptor in the chain
- */
- private volatile JdbcInterceptor next = null;
- /**
- * Property that decides how we do string comparison, default is to use
- * {@link String#equals(Object)}. If set to <code>false</code> then the
- * equality operator (==) is used.
- */
- private boolean useEquals = true;
-
- /**
- * Public constructor for instantiation through reflection
- */
- public JdbcInterceptor() {
- // NOOP
- }
-
- /**
- * Gets invoked each time an operation on {@link java.sql.Connection} is invoked.
- * {@inheritDoc}
- */
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- if (getNext()!=null) return getNext().invoke(proxy,method,args);
- else throw new NullPointerException();
- }
-
- /**
- * Returns the next interceptor in the chain
- * @return the next interceptor in the chain
- */
- public JdbcInterceptor getNext() {
- return next;
- }
-
- /**
- * configures the next interceptor in the chain
- * @param next The next chain item
- */
- public void setNext(JdbcInterceptor next) {
- this.next = next;
- }
-
- /**
- * Performs a string comparison, using references unless the useEquals property is set to true.
- * @param name1 The first name
- * @param name2 The second name
- * @return true if name1 is equal to name2 based on {@link #useEquals}
- */
- public boolean compare(String name1, String name2) {
- if (isUseEquals()) {
- return name1.equals(name2);
- } else {
- return name1==name2;
- }
- }
-
- /**
- * Compares a method name (String) to a method (Method)
- * {@link #compare(String,String)}
- * Uses reference comparison unless the useEquals property is set to true
- * @param methodName The method name
- * @param method The method
- * @return <code>true</code> if the name matches
- */
- public boolean compare(String methodName, Method method) {
- return compare(methodName, method.getName());
- }
-
- /**
- * Gets called each time the connection is borrowed from the pool
- * This means that if an interceptor holds a reference to the connection
- * the interceptor can be reused for another connection.
- * <br>
- * This method may be called with null as both arguments when we are closing down the connection.
- * @param parent - the connection pool owning the connection
- * @param con - the pooled connection
- */
- public abstract void reset(ConnectionPool parent, PooledConnection con);
-
- /**
- * Called when {@link java.sql.Connection#close()} is called on the underlying connection.
- * This is to notify the interceptors, that the physical connection has been released.
- * Implementation of this method should be thought through with care, as no actions should trigger an exception.
- * @param parent - the connection pool that this connection belongs to
- * @param con - the pooled connection that holds this connection
- * @param finalizing - if this connection is finalizing. True means that the pooled connection will not reconnect the underlying connection
- */
- public void disconnected(ConnectionPool parent, PooledConnection con, boolean finalizing) {
- }
-
-
- /**
- * Returns the properties configured for this interceptor
- * @return the configured properties for this interceptor
- */
- public Map<String,InterceptorProperty> getProperties() {
- return properties;
- }
-
- /**
- * Called during the creation of an interceptor
- * The properties can be set during the configuration of an interceptor
- * Override this method to perform type casts between string values and object properties
- * @param properties The properties
- */
- public void setProperties(Map<String,InterceptorProperty> properties) {
- this.properties = properties;
- final String useEquals = "useEquals";
- InterceptorProperty p = properties.get(useEquals);
- if (p!=null) {
- setUseEquals(Boolean.parseBoolean(p.getValue()));
- }
- }
-
- /**
- * @return true if the compare method uses the Object.equals(Object) method
- * false if comparison is done on a reference level
- */
- public boolean isUseEquals() {
- return useEquals;
- }
-
- /**
- * Set to true if string comparisons (for the {@link #compare(String, Method)} and {@link #compare(String, String)} methods) should use the Object.equals(Object) method
- * The default is false
- * @param useEquals <code>true</code> if equals will be used for comparisons
- */
- public void setUseEquals(boolean useEquals) {
- this.useEquals = useEquals;
- }
-
- /**
- * This method is invoked by a connection pool when the pool is closed.
- * Interceptor classes can override this method if they keep static
- * variables or other tracking means around.
- * <b>This method is only invoked on a single instance of the interceptor, and not on every instance created.</b>
- * @param pool - the pool that is being closed.
- */
- public void poolClosed(ConnectionPool pool) {
- // NOOP
- }
-
- /**
- * This method is invoked by a connection pool when the pool is first started up, usually when the first connection is requested.
- * Interceptor classes can override this method if they keep static
- * variables or other tracking means around.
- * <b>This method is only invoked on a single instance of the interceptor, and not on every instance created.</b>
- * @param pool - the pool that is being closed.
- */
- public void poolStarted(ConnectionPool pool) {
- // NOOP
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.NoSuchElementException;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- * <b>EXPERIMENTAL AND NOT YET COMPLETE!</b>
- *
- *
- * An implementation of a blocking queue with fairness waiting and lock dispersal to avoid contention.
- * invocations to method poll(...) will get handed out in the order they were received.
- * Locking is fine grained, a shared lock is only used during the first level of contention, waiting is done in a
- * lock per thread basis so that order is guaranteed once the thread goes into a suspended monitor state.
- * <br>
- * Not all of the methods of the {@link java.util.concurrent.BlockingQueue} are implemented.
- *
- * @param <E> Type of element in the queue
- */
-
-public class MultiLockFairBlockingQueue<E> implements BlockingQueue<E> {
-
- final int LOCK_COUNT = Runtime.getRuntime().availableProcessors();
-
- final AtomicInteger putQueue = new AtomicInteger(0);
- final AtomicInteger pollQueue = new AtomicInteger(0);
-
- public int getNextPut() {
- int idx = Math.abs(putQueue.incrementAndGet()) % LOCK_COUNT;
- return idx;
- }
-
- public int getNextPoll() {
- int idx = Math.abs(pollQueue.incrementAndGet()) % LOCK_COUNT;
- return idx;
- }
- /**
- * Phase one entry lock in order to give out
- * per-thread-locks for the waiting phase we have
- * a phase one lock during the contention period.
- */
- private final ReentrantLock[] locks = new ReentrantLock[LOCK_COUNT];
-
- /**
- * All the objects in the pool are stored in a simple linked list
- */
- final LinkedList<E>[] items;
-
- /**
- * All threads waiting for an object are stored in a linked list
- */
- final LinkedList<ExchangeCountDownLatch<E>>[] waiters;
-
- /**
- * Creates a new fair blocking queue.
- */
- @SuppressWarnings("unchecked") // Can create arrays of generic types
- public MultiLockFairBlockingQueue() {
- items = new LinkedList[LOCK_COUNT];
- waiters = new LinkedList[LOCK_COUNT];
- for (int i=0; i<LOCK_COUNT; i++) {
- items[i] = new LinkedList<>();
- waiters[i] = new LinkedList<>();
- locks[i] = new ReentrantLock(false);
- }
- }
-
- //------------------------------------------------------------------
- // USED BY CONPOOL IMPLEMENTATION
- //------------------------------------------------------------------
- /**
- * Will always return true, queue is unbounded.
- * {@inheritDoc}
- */
- @Override
- public boolean offer(E e) {
- int idx = getNextPut();
- //during the offer, we will grab the main lock
- final ReentrantLock lock = this.locks[idx];
- lock.lock();
- ExchangeCountDownLatch<E> c = null;
- try {
- //check to see if threads are waiting for an object
- if (waiters[idx].size() > 0) {
- //if threads are waiting grab the latch for that thread
- c = waiters[idx].poll();
- //give the object to the thread instead of adding it to the pool
- c.setItem(e);
- } else {
- //we always add first, so that the most recently used object will be given out
- items[idx].addFirst(e);
- }
- } finally {
- lock.unlock();
- }
- //if we exchanged an object with another thread, wake it up.
- if (c!=null) c.countDown();
- //we have an unbounded queue, so always return true
- return true;
- }
-
- /**
- * Will never timeout, as it invokes the {@link #offer(Object)} method.
- * Once a lock has been acquired, the
- * {@inheritDoc}
- */
- @Override
- public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
- return offer(e);
- }
-
- /**
- * Fair retrieval of an object in the queue.
- * Objects are returned in the order the threads requested them.
- * {@inheritDoc}
- */
- @Override
- public E poll(long timeout, TimeUnit unit) throws InterruptedException {
- int idx = getNextPoll();
- E result = null;
- final ReentrantLock lock = this.locks[idx];
- try {
- //acquire the global lock until we know what to do
- lock.lock();
- //check to see if we have objects
- result = items[idx].poll();
- if (result==null && timeout>0) {
- //the queue is empty we will wait for an object
- ExchangeCountDownLatch<E> c = new ExchangeCountDownLatch<>(1);
- //add to the bottom of the wait list
- waiters[idx].addLast(c);
- //unlock the global lock
- lock.unlock();
- //wait for the specified timeout
- if (!c.await(timeout, unit)) {
- //if we timed out, remove ourselves from the waitlist
- lock.lock();
- waiters[idx].remove(c);
- lock.unlock();
- }
- //return the item we received, can be null if we timed out
- result = c.getItem();
- } else {
- //we have an object, release
- lock.unlock();
- }
- } finally {
- if (lock.isHeldByCurrentThread()) {
- lock.unlock();
- }
- }
- return result;
- }
-
- /**
- * Request an item from the queue asynchronously
- * @return - a future pending the result from the queue poll request
- */
- public Future<E> pollAsync() {
- int idx = getNextPoll();
- Future<E> result = null;
- final ReentrantLock lock = this.locks[idx];
- try {
- //grab the global lock
- lock.lock();
- //check to see if we have objects in the queue
- E item = items[idx].poll();
- if (item==null) {
- //queue is empty, add ourselves as waiters
- ExchangeCountDownLatch<E> c = new ExchangeCountDownLatch<>(1);
- waiters[idx].addLast(c);
- //return a future that will wait for the object
- result = new ItemFuture<>(c);
- } else {
- //return a future with the item
- result = new ItemFuture<>(item);
- }
- } finally {
- lock.unlock();
- }
- return result;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean remove(Object e) {
- for (int idx=0; idx<LOCK_COUNT; idx++) {
- final ReentrantLock lock = this.locks[idx];
- lock.lock();
- try {
- boolean result = items[idx].remove(e);
- if (result) return result;
- } finally {
- lock.unlock();
- }
- }
- return false;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int size() {
- int size = 0;
- for (int idx=0; idx<LOCK_COUNT; idx++) {
- size += items[idx].size();
- }
- return size;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Iterator<E> iterator() {
- return new FairIterator();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public E poll() {
- int idx = getNextPoll();
- final ReentrantLock lock = this.locks[idx];
- lock.lock();
- try {
- return items[idx].poll();
- } finally {
- lock.unlock();
- }
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean contains(Object e) {
- for (int idx=0; idx<LOCK_COUNT; idx++) {
- boolean result = items[idx].contains(e);
- if (result) return result;
- }
- return false;
- }
-
-
- //------------------------------------------------------------------
- // NOT USED BY CONPOOL IMPLEMENTATION
- //------------------------------------------------------------------
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean add(E e) {
- return offer(e);
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public int drainTo(Collection<? super E> c, int maxElements) {
- throw new UnsupportedOperationException("int drainTo(Collection<? super E> c, int maxElements)");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public int drainTo(Collection<? super E> c) {
- return drainTo(c,Integer.MAX_VALUE);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void put(E e) throws InterruptedException {
- offer(e);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int remainingCapacity() {
- return Integer.MAX_VALUE - size();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public E take() throws InterruptedException {
- return this.poll(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean addAll(Collection<? extends E> c) {
- Iterator<? extends E> i = c.iterator();
- while (i.hasNext()) {
- E e = i.next();
- offer(e);
- }
- return true;
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public void clear() {
- throw new UnsupportedOperationException("void clear()");
-
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public boolean containsAll(Collection<?> c) {
- throw new UnsupportedOperationException("boolean containsAll(Collection<?> c)");
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isEmpty() {
- return size() == 0;
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public boolean removeAll(Collection<?> c) {
- throw new UnsupportedOperationException("boolean removeAll(Collection<?> c)");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public boolean retainAll(Collection<?> c) {
- throw new UnsupportedOperationException("boolean retainAll(Collection<?> c)");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public Object[] toArray() {
- throw new UnsupportedOperationException("Object[] toArray()");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public <T> T[] toArray(T[] a) {
- throw new UnsupportedOperationException("<T> T[] toArray(T[] a)");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public E element() {
- throw new UnsupportedOperationException("E element()");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public E peek() {
- throw new UnsupportedOperationException("E peek()");
- }
-
- /**
- * {@inheritDoc}
- * @throws UnsupportedOperationException - this operation is not supported
- */
- @Override
- public E remove() {
- throw new UnsupportedOperationException("E remove()");
- }
-
-
-
- //------------------------------------------------------------------
- // Non cancellable Future used to check and see if a connection has been made available
- //------------------------------------------------------------------
- protected class ItemFuture<T> implements Future<T> {
- protected volatile T item = null;
- protected volatile ExchangeCountDownLatch<T> latch = null;
- protected volatile boolean canceled = false;
-
- public ItemFuture(T item) {
- this.item = item;
- }
-
- public ItemFuture(ExchangeCountDownLatch<T> latch) {
- this.latch = latch;
- }
-
- @Override
- public boolean cancel(boolean mayInterruptIfRunning) {
- return false; //don't allow cancel for now
- }
-
- @Override
- public T get() throws InterruptedException, ExecutionException {
- if (item!=null) {
- return item;
- } else if (latch!=null) {
- latch.await();
- return latch.getItem();
- } else {
- throw new ExecutionException("ItemFuture incorrectly instantiated. Bug in the code?", new Exception());
- }
- }
-
- @Override
- public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
- if (item!=null) {
- return item;
- } else if (latch!=null) {
- boolean timedout = !latch.await(timeout, unit);
- if (timedout) throw new TimeoutException();
- else return latch.getItem();
- } else {
- throw new ExecutionException("ItemFuture incorrectly instantiated. Bug in the code?", new Exception());
- }
- }
-
- @Override
- public boolean isCancelled() {
- return false;
- }
-
- @Override
- public boolean isDone() {
- return (item!=null || latch.getItem()!=null);
- }
-
- }
-
- //------------------------------------------------------------------
- // Count down latch that can be used to exchange information
- //------------------------------------------------------------------
- protected class ExchangeCountDownLatch<T> extends CountDownLatch {
- protected volatile T item;
- public ExchangeCountDownLatch(int i) {
- super(i);
- }
- public T getItem() {
- return item;
- }
- public void setItem(T item) {
- this.item = item;
- }
- }
-
- //------------------------------------------------------------------
- // Iterator safe from concurrent modification exceptions
- //------------------------------------------------------------------
- protected class FairIterator implements Iterator<E> {
- E[] elements = null;
- int index;
- E element = null;
-
- @SuppressWarnings("unchecked") // Can't create arrays of generic types
- public FairIterator() {
- ArrayList<E> list = new ArrayList<>(MultiLockFairBlockingQueue.this.size());
- for (int idx=0; idx<LOCK_COUNT; idx++) {
- final ReentrantLock lock = MultiLockFairBlockingQueue.this.locks[idx];
- lock.lock();
- try {
- elements = (E[]) new Object[MultiLockFairBlockingQueue.this.items[idx].size()];
- MultiLockFairBlockingQueue.this.items[idx].toArray(elements);
-
- } finally {
- lock.unlock();
- }
- }
- index = 0;
- elements = (E[]) new Object[list.size()];
- list.toArray(elements);
- }
- @Override
- public boolean hasNext() {
- return index<elements.length;
- }
-
- @Override
- public E next() {
- if (!hasNext()) {
- throw new NoSuchElementException();
- }
- element = elements[index++];
- return element;
- }
-
- @Override
- public void remove() {
- for (int idx=0; idx<LOCK_COUNT; idx++) {
- final ReentrantLock lock = MultiLockFairBlockingQueue.this.locks[idx];
- lock.lock();
- try {
- boolean result = MultiLockFairBlockingQueue.this.items[idx].remove(elements[index]);
- if (result) break;
- } finally {
- lock.unlock();
- }
- }
-
- }
-
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.util.Properties;
-
-import org.apache.tomcat.jdbc.pool.PoolProperties.InterceptorDefinition;
-
-/**
- * A list of properties that are configurable for a connection pool.
- * The {@link DataSource} object also implements this interface so that it can be easily configured through
- * an IoC container without having to specify a secondary object with a setter method.
- *
- */
-
-public interface PoolConfiguration {
-
- /**
- * JMX prefix for interceptors that register themselves with JMX
- */
- public static final String PKG_PREFIX = "org.apache.tomcat.jdbc.pool.interceptor.";
-
- /**
- * Connections that have been abandoned (timed out) wont get closed and reported up unless the number of connections in use are
- * above the percentage defined by abandonWhenPercentageFull.
- * The value should be between 0-100.
- * The default value is 0, which implies that connections are eligible for
- * closure as soon as removeAbandonedTimeout has been reached.
- * @param percentage a value between 0 and 100 to indicate when connections that have been abandoned/timed out are considered abandoned
- */
- public void setAbandonWhenPercentageFull(int percentage);
-
- /**
- * Connections that have been abandoned (timed out) wont get closed and reported up unless the number of connections in use are
- * above the percentage defined by abandonWhenPercentageFull.
- * The value should be between 0-100.
- * The default value is 0, which implies that connections are eligible for
- * closure as soon as removeAbandonedTimeout has been reached.
- * @return percentage - a value between 0 and 100 to indicate when connections that have been abandoned/timed out are considered abandoned
- */
- public int getAbandonWhenPercentageFull();
-
- /**
- * Returns <code>true</code> if a fair queue is being used by the connection pool
- * @return <code>true</code> if a fair waiting queue is being used
- */
- public boolean isFairQueue();
-
- /**
- * Set to true if you wish that calls to getConnection
- * should be treated fairly in a true FIFO fashion.
- * This uses the {@link FairBlockingQueue} implementation for the list of the idle connections.
- * The default value is true.
- * This flag is required when you want to use asynchronous connection retrieval.
- * @param fairQueue <code>true</code> to use a fair queue
- */
- public void setFairQueue(boolean fairQueue);
-
- /**
- * Property not used. Access is always allowed.
- * Access can be achieved by calling unwrap on the pooled connection. see {@link javax.sql.DataSource} interface
- * or call getConnection through reflection or cast the object as {@link javax.sql.PooledConnection}
- * @return <code>true</code>
- */
- public boolean isAccessToUnderlyingConnectionAllowed();
-
- /**
- * No-op
- * @param accessToUnderlyingConnectionAllowed parameter ignored
- */
- public void setAccessToUnderlyingConnectionAllowed(boolean accessToUnderlyingConnectionAllowed);
-
- /**
- * The connection properties that will be sent to the JDBC driver when establishing new connections.
- * Format of the string is [propertyName=property;] <br>
- * NOTE - The "user" and "password" properties will be passed explicitly, so they do not need to be included here.
- * The default value is null.
- * @return the connection properties
- */
- public String getConnectionProperties();
-
- /**
- * The properties that will be passed into {@link java.sql.Driver#connect(String, Properties)} method.
- * Username and password do not need to be stored here, they will be passed into the properties right before the connection is established.
- * @param connectionProperties properties - Format of the string is [propertyName=property;]*
- * Example: prop1=value1;prop2=value2
- */
- public void setConnectionProperties(String connectionProperties);
-
- /**
- * Returns the database properties that are passed into the {@link java.sql.Driver#connect(String, Properties)} method.
- * @return database properties that are passed into the {@link java.sql.Driver#connect(String, Properties)} method.
- */
- public Properties getDbProperties();
-
- /**
- * Overrides the database properties passed into the {@link java.sql.Driver#connect(String, Properties)} method.
- * @param dbProperties The database properties
- */
- public void setDbProperties(Properties dbProperties);
-
- /**
- * The default auto-commit state of connections created by this pool.
- * If not set (null), default is JDBC driver default (If set to null then the {@link java.sql.Connection#setAutoCommit(boolean)} method will not be called.)
- * @return the default auto commit setting, null is Driver default.
- */
- public Boolean isDefaultAutoCommit();
-
- /**
- * The default auto-commit state of connections created by this pool.
- * If not set (null), default is JDBC driver default (If set to null then the {@link java.sql.Connection#setAutoCommit(boolean)} method will not be called.)
- * @return the default auto commit setting, null is Driver default.
- */
- public Boolean getDefaultAutoCommit();
-
- /**
- * The default auto-commit state of connections created by this pool.
- * If not set (null), default is JDBC driver default (If set to null then the {@link java.sql.Connection#setAutoCommit(boolean)} method will not be called.)
- * @param defaultAutoCommit default auto commit setting, null is Driver default.
- */
- public void setDefaultAutoCommit(Boolean defaultAutoCommit);
-
- /**
- * If non null, during connection creation the method {@link java.sql.Connection#setCatalog(String)} will be called with the set value.
- * @return the default catalog, null if not set and accepting the driver default.
- */
- public String getDefaultCatalog();
-
- /**
- * If non null, during connection creation the method {@link java.sql.Connection#setCatalog(String)} will be called with the set value.
- * @param defaultCatalog null if not set and accepting the driver default.
- */
- public void setDefaultCatalog(String defaultCatalog);
-
- /**
- * If non null, during connection creation the method {@link java.sql.Connection#setReadOnly(boolean)} will be called with the set value.
- * @return null if not set and accepting the driver default otherwise the read only value
- */
- public Boolean isDefaultReadOnly();
-
- /**
- * If non null, during connection creation the method {@link java.sql.Connection#setReadOnly(boolean)} will be called with the set value.
- * @return null if not set and accepting the driver default otherwise the read only value
- */
- public Boolean getDefaultReadOnly();
-
- /**
- * If non null, during connection creation the method {@link java.sql.Connection#setReadOnly(boolean)} will be called with the set value.
- * @param defaultReadOnly null if not set and accepting the driver default.
- */
- public void setDefaultReadOnly(Boolean defaultReadOnly);
-
-
- /**
- * Returns the default transaction isolation level. If set to {@link DataSourceFactory#UNKNOWN_TRANSACTIONISOLATION} the method
- * {@link java.sql.Connection#setTransactionIsolation(int)} will not be called during connection creation.
- * @return driver transaction isolation level, or -1 {@link DataSourceFactory#UNKNOWN_TRANSACTIONISOLATION} if not set.
- */
- public int getDefaultTransactionIsolation();
-
- /**
- * If set to {@link DataSourceFactory#UNKNOWN_TRANSACTIONISOLATION} the method
- * {@link java.sql.Connection#setTransactionIsolation(int)} will not be called during connection creation. Otherwise the method
- * will be called with the isolation level set by this property.
- * @param defaultTransactionIsolation a value of {@link java.sql.Connection#TRANSACTION_NONE}, {@link java.sql.Connection#TRANSACTION_READ_COMMITTED},
- * {@link java.sql.Connection#TRANSACTION_READ_UNCOMMITTED}, {@link java.sql.Connection#TRANSACTION_REPEATABLE_READ},
- * {@link java.sql.Connection#TRANSACTION_SERIALIZABLE} or {@link DataSourceFactory#UNKNOWN_TRANSACTIONISOLATION}
- * The last value will not be set on the connection.
- */
- public void setDefaultTransactionIsolation(int defaultTransactionIsolation);
-
- /**
- * The fully qualified Java class name of the JDBC driver to be used. The driver has to be accessible from the same classloader as tomcat-jdbc.jar
- * @return fully qualified JDBC driver name.
- */
- public String getDriverClassName();
-
- /**
- * The fully qualified Java class name of the JDBC driver to be used. The driver has to be accessible from the same classloader as tomcat-jdbc.jar
- * @param driverClassName a fully qualified Java class name of a {@link java.sql.Driver} implementation.
- */
- public void setDriverClassName(String driverClassName);
-
- /**
- * Returns the number of connections that will be established when the connection pool is started.
- * Default value is 10
- * @return number of connections to be started when pool is started
- */
- public int getInitialSize();
-
- /**
- * Set the number of connections that will be established when the connection pool is started.
- * Default value is 10.
- * If this value exceeds {@link #setMaxActive(int)} it will automatically be lowered.
- * @param initialSize the number of connections to be established.
- *
- */
- public void setInitialSize(int initialSize);
-
- /**
- * boolean flag to set if stack traces should be logged for application code which abandoned a Connection.
- * Logging of abandoned Connections adds overhead for every Connection borrow because a stack trace has to be generated.
- * The default value is false.
- * @return true if the connection pool logs stack traces when connections are borrowed from the pool.
- */
- public boolean isLogAbandoned();
-
- /**
- * boolean flag to set if stack traces should be logged for application code which abandoned a Connection.
- * Logging of abandoned Connections adds overhead for every Connection borrow because a stack trace has to be generated.
- * The default value is false.
- * @param logAbandoned set to true if stack traces should be recorded when {@link DataSource#getConnection()} is called.
- */
- public void setLogAbandoned(boolean logAbandoned);
-
- /**
- * The maximum number of active connections that can be allocated from this pool at the same time. The default value is 100
- * @return the maximum number of connections used by this pool
- */
- public int getMaxActive();
-
- /**
- * The maximum number of active connections that can be allocated from this pool at the same time. The default value is 100
- * @param maxActive hard limit for number of managed connections by this pool
- */
- public void setMaxActive(int maxActive);
-
-
- /**
- * The maximum number of connections that should be kept in the idle pool if {@link #isPoolSweeperEnabled()} returns false.
- * If the If {@link #isPoolSweeperEnabled()} returns true, then the idle pool can grow up to {@link #getMaxActive}
- * and will be shrunk according to {@link #getMinEvictableIdleTimeMillis()} setting.
- * Default value is maxActive:100
- * @return the maximum number of idle connections.
- */
- public int getMaxIdle();
-
- /**
- * The maximum number of connections that should be kept in the idle pool if {@link #isPoolSweeperEnabled()} returns false.
- * If the If {@link #isPoolSweeperEnabled()} returns true, then the idle pool can grow up to {@link #getMaxActive}
- * and will be shrunk according to {@link #getMinEvictableIdleTimeMillis()} setting.
- * Default value is maxActive:100
- * @param maxIdle the maximum size of the idle pool
- */
- public void setMaxIdle(int maxIdle);
-
- /**
- * The maximum number of milliseconds that the pool will wait (when there are no available connections and the
- * {@link #getMaxActive} has been reached) for a connection to be returned
- * before throwing an exception. Default value is 30000 (30 seconds)
- * @return the number of milliseconds to wait for a connection to become available if the pool is maxed out.
- */
- public int getMaxWait();
-
- /**
- * The maximum number of milliseconds that the pool will wait (when there are no available connections and the
- * {@link #getMaxActive} has been reached) for a connection to be returned
- * before throwing an exception. Default value is 30000 (30 seconds)
- * @param maxWait the maximum number of milliseconds to wait.
- */
- public void setMaxWait(int maxWait);
-
- /**
- * The minimum amount of time an object must sit idle in the pool before it is eligible for eviction.
- * The default value is 60000 (60 seconds).
- * @return the minimum amount of idle time in milliseconds before a connection is considered idle and eligible for eviction.
- */
- public int getMinEvictableIdleTimeMillis();
-
- /**
- * The minimum amount of time an object must sit idle in the pool before it is eligible for eviction.
- * The default value is 60000 (60 seconds).
- * @param minEvictableIdleTimeMillis the number of milliseconds a connection must be idle to be eligible for eviction.
- */
- public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis);
-
- /**
- * The minimum number of established connections that should be kept in the pool at all times.
- * The connection pool can shrink below this number if validation queries fail and connections get closed.
- * Default value is derived from {@link #getInitialSize()} (also see {@link #setTestWhileIdle(boolean)}
- * The idle pool will not shrink below this value during an eviction run, hence the number of actual connections
- * can be between {@link #getMinIdle()} and somewhere between {@link #getMaxIdle()} and {@link #getMaxActive()}
- * @return the minimum number of idle or established connections
- */
- public int getMinIdle();
-
- /**
- * The minimum number of established connections that should be kept in the pool at all times.
- * The connection pool can shrink below this number if validation queries fail and connections get closed.
- * Default value is derived from {@link #getInitialSize()} (also see {@link #setTestWhileIdle(boolean)}
- * The idle pool will not shrink below this value during an eviction run, hence the number of actual connections
- * can be between {@link #getMinIdle()} and somewhere between {@link #getMaxIdle()} and {@link #getMaxActive()}
- *
- * @param minIdle the minimum number of idle or established connections
- */
- public void setMinIdle(int minIdle);
-
- /**
- * Returns the name of the connection pool. By default a JVM unique random name is assigned.
- * @return the name of the pool, should be unique in a JVM
- */
- public String getName();
-
- /**
- * Sets the name of the connection pool
- * @param name the name of the pool, should be unique in a runtime JVM
- */
- public void setName(String name);
-
- /**
- * Property not used
- * @return unknown value
- */
- public int getNumTestsPerEvictionRun();
-
- /**
- * Property not used
- * @param numTestsPerEvictionRun parameter ignored.
- */
- public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun);
-
- /**
- * Returns the password used when establishing connections to the database.
- * @return the password in string format
- */
- public String getPassword();
-
- /**
- * Sets the password to establish the connection with.
- * The password will be included as a database property with the name 'password'.
- * @param password The password
- * @see #getDbProperties()
- */
- public void setPassword(String password);
-
- /**
- * @see #getName()
- * @return the pool name
- */
- public String getPoolName();
-
- /**
- * Returns the username used to establish the connection with
- * @return the username used to establish the connection with
- */
- public String getUsername();
-
- /**
- * Sets the username used to establish the connection with
- * It will also be a property called 'user' in the database properties.
- * @param username The user name
- * @see #getDbProperties()
- */
- public void setUsername(String username);
-
-
- /**
- * boolean flag to remove abandoned connections if they exceed the removeAbandonedTimout.
- * If set to true a connection is considered abandoned and eligible for removal if it has
- * been in use longer than the {@link #getRemoveAbandonedTimeout()} and the condition for
- * {@link #getAbandonWhenPercentageFull()} is met.
- * Setting this to true can recover db connections from applications that fail to close a connection.
- * See also {@link #isLogAbandoned()} The default value is false.
- * @return true if abandoned connections can be closed and expelled out of the pool
- */
- public boolean isRemoveAbandoned();
-
- /**
- * boolean flag to remove abandoned connections if they exceed the removeAbandonedTimout.
- * If set to true a connection is considered abandoned and eligible for removal if it has
- * been in use longer than the {@link #getRemoveAbandonedTimeout()} and the condition for
- * {@link #getAbandonWhenPercentageFull()} is met.
- * Setting this to true can recover db connections from applications that fail to close a connection.
- * See also {@link #isLogAbandoned()} The default value is false.
- * @param removeAbandoned set to true if abandoned connections can be closed and expelled out of the pool
- */
- public void setRemoveAbandoned(boolean removeAbandoned);
-
- /**
- * The time in seconds before a connection can be considered abandoned.
- * The timer can be reset upon queries using an interceptor.
- * @param removeAbandonedTimeout the time in seconds before a used connection can be considered abandoned
- * @see org.apache.tomcat.jdbc.pool.interceptor.ResetAbandonedTimer
- */
- public void setRemoveAbandonedTimeout(int removeAbandonedTimeout);
-
- /**
- * The time in seconds before a connection can be considered abandoned.
- * The timer can be reset upon queries using an interceptor.
- * @see org.apache.tomcat.jdbc.pool.interceptor.ResetAbandonedTimer
- * @return the time in seconds before a used connection can be considered abandoned
- */
- public int getRemoveAbandonedTimeout();
-
- /**
- * The indication of whether objects will be validated before being borrowed from the pool.
- * If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another.
- * NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string.
- * Default value is false
- * In order to have a more efficient validation, see {@link #setValidationInterval(long)}
- * @return true if the connection is to be validated upon borrowing a connection from the pool
- * @see #getValidationInterval()
- */
- public boolean isTestOnBorrow();
-
- /**
- * The indication of whether objects will be validated before being borrowed from the pool.
- * If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another.
- * NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string.
- * Default value is false
- * In order to have a more efficient validation, see {@link #setValidationInterval(long)}
- * @param testOnBorrow set to true if validation should take place before a connection is handed out to the application
- * @see #getValidationInterval()
- */
- public void setTestOnBorrow(boolean testOnBorrow);
-
- /**
- * The indication of whether objects will be validated after being returned to the pool.
- * If the object fails to validate, it will be dropped from the pool.
- * NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string.
- * Default value is false
- * In order to have a more efficient validation, see {@link #setValidationInterval(long)}
- * @return true if validation should take place after a connection is returned to the pool
- * @see #getValidationInterval()
- */
- public boolean isTestOnReturn();
-
- /**
- * The indication of whether objects will be validated after being returned to the pool.
- * If the object fails to validate, it will be dropped from the pool.
- * NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string.
- * Default value is false
- * In order to have a more efficient validation, see {@link #setValidationInterval(long)}
- * @param testOnReturn true if validation should take place after a connection is returned to the pool
- * @see #getValidationInterval()
- */
- public void setTestOnReturn(boolean testOnReturn);
-
-
- /**
- * Set to true if query validation should take place while the connection is idle.
- * @return true if validation should take place during idle checks
- * @see #setTimeBetweenEvictionRunsMillis(int)
- */
- public boolean isTestWhileIdle();
-
- /**
- * Set to true if query validation should take place while the connection is idle.
- * @param testWhileIdle true if validation should take place during idle checks
- * @see #setTimeBetweenEvictionRunsMillis(int)
- */
- public void setTestWhileIdle(boolean testWhileIdle);
-
- /**
- * The number of milliseconds to sleep between runs of the idle connection validation, abandoned cleaner
- * and idle pool resizing. This value should not be set under 1 second.
- * It dictates how often we check for idle, abandoned connections, and how often we validate idle connection and resize the idle pool.
- * The default value is 5000 (5 seconds)
- * @return the sleep time in between validations in milliseconds
- */
- public int getTimeBetweenEvictionRunsMillis();
-
- /**
- * The number of milliseconds to sleep between runs of the idle connection validation, abandoned cleaner
- * and idle pool resizing. This value should not be set under 1 second.
- * It dictates how often we check for idle, abandoned connections, and how often we validate idle connection and resize the idle pool.
- * The default value is 5000 (5 seconds)
- * @param timeBetweenEvictionRunsMillis the sleep time in between validations in milliseconds
- */
- public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis);
-
- /**
- * The URL used to connect to the database
- * @return the configured URL for this connection pool
- * @see java.sql.Driver#connect(String, Properties)
- */
- public String getUrl();
-
- /**
- * Sets the URL used to connect to the database
- * @param url the configured URL for this connection pool
- * @see java.sql.Driver#connect(String, Properties)
- */
- public void setUrl(String url);
-
- /**
- * The SQL query that will be used to validate connections from this
- * pool before returning them to the caller or pool.
- * If specified, this query does not have to return any data,
- * it just can't throw a SQLException.
- * The default value is null.
- * Example values are SELECT 1(mysql),
- * select 1 from dual(oracle),
- * SELECT 1(MS Sql Server)
- * @return the query used for validation or null if no validation is performed
- */
- public String getValidationQuery();
-
- /**
- * The SQL query that will be used to validate connections from this
- * pool before returning them to the caller or pool.
- * If specified, this query does not have to return any data,
- * it just can't throw a SQLException.
- * The default value is null.
- * Example values are SELECT 1(mysql),
- * select 1 from dual(oracle),
- * SELECT 1(MS Sql Server)
- * @param validationQuery the query used for validation or null if no validation is performed
- */
- public void setValidationQuery(String validationQuery);
-
- /**
- * The timeout in seconds before a connection validation queries fail.
- * A value less than or equal to zero will disable this feature. Defaults to -1.
- * @return the timeout value in seconds
- */
- public int getValidationQueryTimeout();
-
- /**
- * The timeout in seconds before a connection validation queries fail.
- * A value less than or equal to zero will disable this feature. Defaults to -1.
- * @param validationQueryTimeout The timeout value
- */
- public void setValidationQueryTimeout(int validationQueryTimeout);
-
- /**
- * Return the name of the optional validator class - may be null.
- *
- * @return the name of the optional validator class - may be null
- */
- public String getValidatorClassName();
-
- /**
- * Set the name for an optional validator class which will be used in place of test queries. If set to
- * null, standard validation will be used.
- *
- * @param className the name of the optional validator class
- */
- public void setValidatorClassName(String className);
-
- /**
- * @return the optional validator object - may be null
- */
- public Validator getValidator();
-
- /**
- * Sets the validator object
- * If this is a non null object, it will be used as a validator instead of the validationQuery
- * If this is null, remove the usage of the validator.
- * @param validator The validator object
- */
- public void setValidator(Validator validator);
-
- /**
- * avoid excess validation, only run validation at most at this frequency - time in milliseconds.
- * If a connection is due for validation, but has been validated previously
- * within this interval, it will not be validated again.
- * The default value is 3000 (3 seconds).
- * @return the validation interval in milliseconds
- */
- public long getValidationInterval();
-
- /**
- * avoid excess validation, only run validation at most at this frequency - time in milliseconds.
- * If a connection is due for validation, but has been validated previously
- * within this interval, it will not be validated again.
- * The default value is 3000 (3 seconds).
- * @param validationInterval the validation interval in milliseconds
- */
- public void setValidationInterval(long validationInterval);
-
- /**
- * A custom query to be run when a connection is first created. The default value is null.
- * This query only runs once per connection, and that is when a new connection is established to the database.
- * If this value is non null, it will replace the validation query during connection creation.
- * @return the init SQL used to run against the DB or null if not set
- */
- public String getInitSQL();
-
- /**
- * A custom query to be run when a connection is first created. The default value is null.
- * This query only runs once per connection, and that is when a new connection is established to the database.
- * If this value is non null, it will replace the validation query during connection creation.
- * @param initSQL the init SQL used to run against the DB or null if no query should be executed
- */
- public void setInitSQL(String initSQL);
-
- /**
- * Returns true if we should run the validation query when connecting to the database for the first time on a connection.
- * Normally this is always set to false, unless one wants to use the validationQuery as an init query.
- * @return true if we should run the validation query upon connect
- */
- public boolean isTestOnConnect();
-
- /**
- * Set to true if we should run the validation query when connecting to the database for the first time on a connection.
- * Normally this is always set to false, unless one wants to use the validationQuery as an init query.
- * Setting an {@link #setInitSQL(String)} will override this setting, as the init SQL will be used instead of the validation query
- * @param testOnConnect set to true if we should run the validation query upon connect
- */
- public void setTestOnConnect(boolean testOnConnect);
-
- /**
- * A semicolon separated list of classnames extending {@link org.apache.tomcat.jdbc.pool.JdbcInterceptor} class.
- * These interceptors will be inserted as an interceptor into the chain of operations on a java.sql.Connection object.
- * Example interceptors are {@link org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer StatementFinalizer} to close all
- * used statements during the session.
- * {@link org.apache.tomcat.jdbc.pool.interceptor.ResetAbandonedTimer ResetAbandonedTimer} resets the timer upon every operation
- * on the connection or a statement.
- * {@link org.apache.tomcat.jdbc.pool.interceptor.ConnectionState ConnectionState} caches the auto commit, read only and catalog settings to avoid round trips to the DB.
- * The default value is null.
- * @return the interceptors that are used for connections.
- * Example format: 'ConnectionState(useEquals=true,fast=yes);ResetAbandonedTimer'
- */
- public String getJdbcInterceptors();
-
- /**
- * A semicolon separated list of classnames extending {@link org.apache.tomcat.jdbc.pool.JdbcInterceptor} class.
- * These interceptors will be inserted as an interceptor into the chain of operations on a java.sql.Connection object.
- * Example interceptors are {@link org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer StatementFinalizer} to close all
- * used statements during the session.
- * {@link org.apache.tomcat.jdbc.pool.interceptor.ResetAbandonedTimer ResetAbandonedTimer} resets the timer upon every operation
- * on the connection or a statement.
- * {@link org.apache.tomcat.jdbc.pool.interceptor.ConnectionState ConnectionState} caches the auto commit, read only and catalog settings to avoid round trips to the DB.
- * The default value is null.
- * @param jdbcInterceptors the interceptors that are used for connections.
- * Example format: 'ConnectionState(useEquals=true,fast=yes);ResetAbandonedTimer'
- */
- public void setJdbcInterceptors(String jdbcInterceptors);
-
- /**
- * Returns the {@link #getJdbcInterceptors()} as an array of objects with properties and the classes.
- * @return an array of interceptors that have been configured
- */
- public InterceptorDefinition[] getJdbcInterceptorsAsArray();
-
-
- /**
- * If set to true, the connection pool creates a {@link org.apache.tomcat.jdbc.pool.jmx.ConnectionPoolMBean} object
- * that can be registered with JMX to receive notifications and state about the pool.
- * The ConnectionPool object doesn't register itself, as there is no way to keep a static non changing ObjectName across JVM restarts.
- * @return true if the mbean object will be created upon startup.
- */
- public boolean isJmxEnabled();
-
- /**
- * If set to true, the connection pool creates a {@link org.apache.tomcat.jdbc.pool.jmx.ConnectionPoolMBean} object
- * that can be registered with JMX to receive notifications and state about the pool.
- * The ConnectionPool object doesn't register itself, as there is no way to keep a static non changing ObjectName across JVM restarts.
- * @param jmxEnabled set to to if the mbean object should be created upon startup.
- */
- public void setJmxEnabled(boolean jmxEnabled);
-
- /**
- * Returns true if the pool sweeper is enabled for the connection pool.
- * The pool sweeper is enabled if any settings that require async intervention in the pool are turned on
- * <code>
- boolean result = getTimeBetweenEvictionRunsMillis()>0;
- result = result && (isRemoveAbandoned() && getRemoveAbandonedTimeout()>0);
- result = result || (isTestWhileIdle() && getValidationQuery()!=null);
- return result;
- </code>
- *
- * @return true if a background thread is or will be enabled for this pool
- */
- public boolean isPoolSweeperEnabled();
-
- /**
- * Set to true if you wish the <code>ProxyConnection</code> class to use <code>String.equals</code> instead of
- * <code>==</code> when comparing method names.
- * This property does not apply to added interceptors as those are configured individually.
- * The default value is <code>false</code>.
- * @return true if pool uses {@link String#equals(Object)} instead of == when comparing method names on {@link java.sql.Connection} methods
- */
- public boolean isUseEquals();
-
- /**
- * Set to true if you wish the <code>ProxyConnection</code> class to use <code>String.equals</code> instead of
- * <code>==</code> when comparing method names.
- * This property does not apply to added interceptors as those are configured individually.
- * The default value is <code>false</code>.
- * @param useEquals set to true if the pool should use {@link String#equals(Object)} instead of ==
- * when comparing method names on {@link java.sql.Connection} methods
- */
- public void setUseEquals(boolean useEquals);
-
- /**
- * Time in milliseconds to keep this connection alive even when used.
- * When a connection is returned to the pool, the pool will check to see if the
- * ((now - time-when-connected) > maxAge) has been reached, and if so,
- * it closes the connection rather than returning it to the pool.
- * The default value is 0, which implies that connections will be left open and no
- * age check will be done upon returning the connection to the pool.
- * This is a useful setting for database sessions that leak memory as it ensures that the session
- * will have a finite life span.
- * @return the time in milliseconds a connection will be open for when used
- */
- public long getMaxAge();
-
- /**
- * Time in milliseconds to keep this connection alive even when used.
- * When a connection is returned to the pool, the pool will check to see if the
- * ((now - time-when-connected) > maxAge) has been reached, and if so,
- * it closes the connection rather than returning it to the pool.
- * The default value is 0, which implies that connections will be left open and no
- * age check will be done upon returning the connection to the pool.
- * This is a useful setting for database sessions that leak memory as it ensures that the session
- * will have a finite life span.
- * @param maxAge the time in milliseconds a connection will be open for when used
- */
- public void setMaxAge(long maxAge);
-
- /**
- * Return true if a lock should be used when operations are performed on the connection object.
- * Should be set to false unless you plan to have a background thread of your own doing idle and abandon checking
- * such as JMX clients. If the pool sweeper is enabled, then the lock will automatically be used regardless of this setting.
- * @return true if a lock is used.
- */
- public boolean getUseLock();
-
- /**
- * Set to true if a lock should be used when operations are performed on the connection object.
- * Should be set to false unless you plan to have a background thread of your own doing idle and abandon checking
- * such as JMX clients. If the pool sweeper is enabled, then the lock will automatically be used regardless of this setting.
- * @param useLock set to true if a lock should be used on connection operations
- */
- public void setUseLock(boolean useLock);
-
- /**
- * Similar to {@link #setRemoveAbandonedTimeout(int)} but instead of treating the connection
- * as abandoned, and potentially closing the connection, this simply logs the warning if
- * {@link #isLogAbandoned()} returns true. If this value is equal or less than 0, no suspect
- * checking will be performed. Suspect checking only takes place if the timeout value is larger than 0 and
- * the connection was not abandoned or if abandon check is disabled. If a connection is suspect a WARN message gets
- * logged and a JMX notification gets sent once.
- * @param seconds - the amount of time in seconds that has to pass before a connection is marked suspect.
- */
- public void setSuspectTimeout(int seconds);
-
- /**
- * Returns the time in seconds to pass before a connection is marked an abandoned suspect.
- * Any value lesser than or equal to 0 means the check is disabled.
- * @return Returns the time in seconds to pass before a connection is marked an abandoned suspect.
- */
- public int getSuspectTimeout();
-
- /**
- * Injects a datasource that will be used to retrieve/create connections.
- * If a data source is set, the {@link PoolConfiguration#getUrl()} and {@link PoolConfiguration#getDriverClassName()} methods are ignored
- * and not used by the pool. If the {@link PoolConfiguration#getUsername()} and {@link PoolConfiguration#getPassword()}
- * values are set, the method {@link javax.sql.DataSource#getConnection(String, String)} method will be called instead of the
- * {@link javax.sql.DataSource#getConnection()} method.
- * If the data source implements {@link javax.sql.XADataSource} the methods
- * {@link javax.sql.XADataSource#getXAConnection()} and {@link javax.sql.XADataSource#getXAConnection(String,String)}
- * will be invoked.
- * @param ds the {@link javax.sql.DataSource} to be used for creating connections to be pooled.
- */
- public void setDataSource(Object ds);
-
- /**
- * Returns a datasource, if one exists that is being used to create connections.
- * This method will return null if the pool is using a {@link java.sql.Driver}
- * @return the {@link javax.sql.DataSource} to be used for creating connections to be pooled or null if a Driver is used.
- */
- public Object getDataSource();
-
- /**
- * Configure the connection pool to use a DataSource according to {@link PoolConfiguration#setDataSource(Object)}
- * But instead of injecting the object, specify the JNDI location.
- * After a successful JNDI look, the {@link PoolConfiguration#getDataSource()} will not return null.
- * @param jndiDS -the JNDI string @TODO specify the rules here.
- */
- public void setDataSourceJNDI(String jndiDS);
-
- /**
- * Returns the JNDI string configured for data source usage.
- * @return the JNDI string or null if not set
- */
- public String getDataSourceJNDI();
-
- /**
- * Returns true if the call {@link DataSource#getConnection(String, String) getConnection(username,password)} is
- * allowed. This is used for when the pool is used by an application accessing multiple schemas.
- * There is a performance impact turning this option on.
- * @return true if {@link DataSource#getConnection(String, String) getConnection(username,password)} is honored, false if it is ignored.
- */
- public boolean isAlternateUsernameAllowed();
-
- /**
- * Set to true if the call {@link DataSource#getConnection(String, String) getConnection(username,password)} is
- * allowed and honored.. This is used for when the pool is used by an application accessing multiple schemas.
- * There is a performance impact turning this option on, even when not used due to username checks.
- * @param alternateUsernameAllowed - set true if {@link DataSource#getConnection(String, String) getConnection(username,password)} is honored,
- * false if it is to be ignored.
- */
- public void setAlternateUsernameAllowed(boolean alternateUsernameAllowed);
- /**
- * Set to true if you want the connection pool to commit any pending transaction when a connection is returned.
- * The default value is false, as this could result in committing data.
- * This parameter is only looked at if the {@link #getDefaultAutoCommit()} returns false
- * @param commitOnReturn set to true if the pool should call {@link java.sql.Connection#commit()} when a connection is returned to the pool.
- * Default is false
- */
- public void setCommitOnReturn(boolean commitOnReturn);
-
- /**
- * @see PoolConfiguration#setCommitOnReturn(boolean)
- * @return <code>true</code> if the pool should commit when a connection is returned to it
- */
- public boolean getCommitOnReturn();
-
- /**
- * Set to true if you want the connection pool to rollback any pending transaction when a connection is returned.
- * The default value is false, as this could result in committing data.
- * This parameter is only looked at if the {@link #getDefaultAutoCommit()} returns false
- * @param rollbackOnReturn set to true if the pool should call {@link java.sql.Connection#rollback()} when a connection is returned to the pool.
- * Default is false
- */
- public void setRollbackOnReturn(boolean rollbackOnReturn);
-
- /**
- * @see PoolConfiguration#setRollbackOnReturn(boolean)
- * @return <code>true</code> if the pool should rollback when a connection is returned to it
- */
- public boolean getRollbackOnReturn();
-
- /**
- * If set to <code>true</code>, the connection will be wrapped with facade that will disallow the connection to be used after
- * {@link java.sql.Connection#close()} is called. If set to <code>true</code>, after {@link java.sql.Connection#close()} all calls except
- * {@link java.sql.Connection#close()} and {@link java.sql.Connection#isClosed()} will throw an exception.
- * @param useDisposableConnectionFacade <code>true</code> to use a facade
- */
- public void setUseDisposableConnectionFacade(boolean useDisposableConnectionFacade);
- /**
- * Returns <code>true</code> if this connection pool is configured to use a connection facade to prevent re-use of connection after
- * {@link java.sql.Connection#close()} has been invoked
- * @return <code>true</code> if {@link java.sql.Connection#close()} has been invoked.
- */
- public boolean getUseDisposableConnectionFacade();
-
- /**
- * Set to true if you wish that errors from validation should be logged as error messages.
- * @param logValidationErrors set to true to log validation errors
- */
- public void setLogValidationErrors(boolean logValidationErrors);
-
- /**
- * Returns true if errors that happen during validation will be logged
- * @return true if errors that happen during validation will be logged
- */
- public boolean getLogValidationErrors();
-
- /**
- * Returns true if the pool is configured to propagate interrupt state of a thread.
- * A thread waiting for a connection, can have its wait interrupted, and by default
- * will clear the interrupt flag and throw a {@link PoolExhaustedException}
- * @return true if the pool is configured to propagate and not clear the thread interrupt state
- */
- public boolean getPropagateInterruptState();
-
- /**
- * Configure the pool to propagate interrupt state for interrupted threads waiting for a connection
- * A thread waiting for a connection, can have its wait interrupted, and by default
- * will clear the interrupt flag and throw a {@link PoolExhaustedException}
- * If set to true, this behavior will change, while the {@link PoolExhaustedException} is still thrown, the threads interrupted state is still set.
- * @param propagateInterruptState - set to true to not clear, but propagate, a threads interrupted state.
- */
- public void setPropagateInterruptState(boolean propagateInterruptState);
-
- /**
- * Set to true if you want to ignore error of connection creation while initializing the pool.
- * Set to false if you want to fail the initialization of the pool by throwing exception.
- * @param ignoreExceptionOnPreLoad set to true if you want to ignore error of connection creation while initializing the pool.
- */
- public void setIgnoreExceptionOnPreLoad(boolean ignoreExceptionOnPreLoad);
-
- /**
- * @return <code>true</code> to ignore exceptions
- * @see PoolConfiguration#setIgnoreExceptionOnPreLoad(boolean)
- */
- public boolean isIgnoreExceptionOnPreLoad();
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.sql.SQLException;
-
-public class PoolExhaustedException extends SQLException {
-
- private static final long serialVersionUID = 3501536931777262475L;
-
- public PoolExhaustedException() {
- }
-
- public PoolExhaustedException(String reason) {
- super(reason);
- }
-
- public PoolExhaustedException(Throwable cause) {
- super(cause);
- }
-
- public PoolExhaustedException(String reason, String SQLState) {
- super(reason, SQLState);
- }
-
- public PoolExhaustedException(String reason, Throwable cause) {
- super(reason, cause);
- }
-
- public PoolExhaustedException(String reason, String SQLState, int vendorCode) {
- super(reason, SQLState, vendorCode);
- }
-
- public PoolExhaustedException(String reason, String sqlState, Throwable cause) {
- super(reason, sqlState, cause);
- }
-
- public PoolExhaustedException(String reason, String sqlState, int vendorCode, Throwable cause) {
- super(reason, sqlState, vendorCode, cause);
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.Serializable;
-import java.lang.reflect.Method;
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Properties;
-import java.util.concurrent.atomic.AtomicInteger;
-
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-
-public class PoolProperties implements PoolConfiguration, Cloneable, Serializable {
-
- private static final long serialVersionUID = -8519283440854213745L;
- private static final Log log = LogFactory.getLog(PoolProperties.class);
-
- public static final int DEFAULT_MAX_ACTIVE = 100;
-
- protected static final AtomicInteger poolCounter = new AtomicInteger(0);
- private volatile Properties dbProperties = new Properties();
- private volatile String url = null;
- private volatile String driverClassName = null;
- private volatile Boolean defaultAutoCommit = null;
- private volatile Boolean defaultReadOnly = null;
- private volatile int defaultTransactionIsolation = DataSourceFactory.UNKNOWN_TRANSACTIONISOLATION;
- private volatile String defaultCatalog = null;
- private volatile String connectionProperties;
- private volatile int initialSize = 10;
- private volatile int maxActive = DEFAULT_MAX_ACTIVE;
- private volatile int maxIdle = maxActive;
- private volatile int minIdle = initialSize;
- private volatile int maxWait = 30000;
- private volatile String validationQuery;
- private volatile int validationQueryTimeout = -1;
- private volatile String validatorClassName;
- private volatile Validator validator;
- private volatile boolean testOnBorrow = false;
- private volatile boolean testOnReturn = false;
- private volatile boolean testWhileIdle = false;
- private volatile int timeBetweenEvictionRunsMillis = 5000;
- private volatile int numTestsPerEvictionRun;
- private volatile int minEvictableIdleTimeMillis = 60000;
- private volatile boolean accessToUnderlyingConnectionAllowed = true;
- private volatile boolean removeAbandoned = false;
- private volatile int removeAbandonedTimeout = 60;
- private volatile boolean logAbandoned = false;
- private volatile String name = "Tomcat Connection Pool["+(poolCounter.addAndGet(1))+"-"+System.identityHashCode(PoolProperties.class)+"]";
- private volatile String password;
- private volatile String username;
- private volatile long validationInterval = 3000;
- private volatile boolean jmxEnabled = true;
- private volatile String initSQL;
- private volatile boolean testOnConnect =false;
- private volatile String jdbcInterceptors=null;
- private volatile boolean fairQueue = true;
- private volatile boolean useEquals = true;
- private volatile int abandonWhenPercentageFull = 0;
- private volatile long maxAge = 0;
- private volatile boolean useLock = false;
- private volatile InterceptorDefinition[] interceptors = null;
- private volatile int suspectTimeout = 0;
- private volatile Object dataSource = null;
- private volatile String dataSourceJNDI = null;
- private volatile boolean alternateUsernameAllowed = false;
- private volatile boolean commitOnReturn = false;
- private volatile boolean rollbackOnReturn = false;
- private volatile boolean useDisposableConnectionFacade = true;
- private volatile boolean logValidationErrors = false;
- private volatile boolean propagateInterruptState = false;
- private volatile boolean ignoreExceptionOnPreLoad = false;
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setAbandonWhenPercentageFull(int percentage) {
- if (percentage<0) abandonWhenPercentageFull = 0;
- else if (percentage>100) abandonWhenPercentageFull = 100;
- else abandonWhenPercentageFull = percentage;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int getAbandonWhenPercentageFull() {
- return abandonWhenPercentageFull;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isFairQueue() {
- return fairQueue;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setFairQueue(boolean fairQueue) {
- this.fairQueue = fairQueue;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isAccessToUnderlyingConnectionAllowed() {
- return accessToUnderlyingConnectionAllowed;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getConnectionProperties() {
- return connectionProperties;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Properties getDbProperties() {
- return dbProperties;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Boolean isDefaultAutoCommit() {
- return defaultAutoCommit;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getDefaultCatalog() {
- return defaultCatalog;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Boolean isDefaultReadOnly() {
- return defaultReadOnly;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getDefaultTransactionIsolation() {
- return defaultTransactionIsolation;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getDriverClassName() {
- return driverClassName;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getInitialSize() {
- return initialSize;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isLogAbandoned() {
- return logAbandoned;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMaxActive() {
- return maxActive;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMaxIdle() {
- return maxIdle;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMaxWait() {
- return maxWait;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMinEvictableIdleTimeMillis() {
- return minEvictableIdleTimeMillis;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getMinIdle() {
- return minIdle;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getName() {
- return name;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getNumTestsPerEvictionRun() {
- return numTestsPerEvictionRun;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getPassword() {
- return password;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getPoolName() {
- return getName();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isRemoveAbandoned() {
- return removeAbandoned;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getRemoveAbandonedTimeout() {
- return removeAbandonedTimeout;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isTestOnBorrow() {
- return testOnBorrow;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isTestOnReturn() {
- return testOnReturn;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isTestWhileIdle() {
- return testWhileIdle;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getTimeBetweenEvictionRunsMillis() {
- return timeBetweenEvictionRunsMillis;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getUrl() {
- return url;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getUsername() {
- return username;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getValidationQuery() {
- return validationQuery;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int getValidationQueryTimeout() {
- return validationQueryTimeout;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setValidationQueryTimeout(int validationQueryTimeout) {
- this.validationQueryTimeout = validationQueryTimeout;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getValidatorClassName() {
- return validatorClassName;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Validator getValidator() {
- return validator;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setValidator(Validator validator) {
- this.validator = validator;
- if (validator!=null) {
- this.validatorClassName = validator.getClass().getName();
- } else {
- this.validatorClassName = null;
- }
- }
-
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public long getValidationInterval() {
- return validationInterval;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getInitSQL() {
- return initSQL;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isTestOnConnect() {
- return testOnConnect;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getJdbcInterceptors() {
- return jdbcInterceptors;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public InterceptorDefinition[] getJdbcInterceptorsAsArray() {
- if (interceptors == null) {
- if (jdbcInterceptors==null) {
- interceptors = new InterceptorDefinition[0];
- } else {
- String[] interceptorValues = jdbcInterceptors.split(";");
- InterceptorDefinition[] definitions = new InterceptorDefinition[interceptorValues.length+1];
- //always add the trap interceptor to the mix
- definitions[0] = new InterceptorDefinition(TrapException.class);
- for (int i=0; i<interceptorValues.length; i++) {
- int propIndex = interceptorValues[i].indexOf('(');
- int endIndex = interceptorValues[i].indexOf(')');
- if (propIndex<0 || endIndex<0 || endIndex <= propIndex) {
- definitions[i+1] = new InterceptorDefinition(interceptorValues[i].trim());
- } else {
- String name = interceptorValues[i].substring(0,propIndex).trim();
- definitions[i+1] = new InterceptorDefinition(name);
- String propsAsString = interceptorValues[i].substring(propIndex+1, endIndex);
- String[] props = propsAsString.split(",");
- for (int j=0; j<props.length; j++) {
- int pidx = props[j].indexOf('=');
- String propName = props[j].substring(0,pidx).trim();
- String propValue = props[j].substring(pidx+1).trim();
- definitions[i+1].addProperty(new InterceptorProperty(propName,propValue));
- }
- }
- }
- interceptors = definitions;
- }
- }
- return interceptors;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setAccessToUnderlyingConnectionAllowed(boolean accessToUnderlyingConnectionAllowed) {
- // NOOP
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setConnectionProperties(String connectionProperties) {
- this.connectionProperties = connectionProperties;
- getProperties(connectionProperties, getDbProperties());
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDbProperties(Properties dbProperties) {
- this.dbProperties = dbProperties;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDefaultAutoCommit(Boolean defaultAutoCommit) {
- this.defaultAutoCommit = defaultAutoCommit;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDefaultCatalog(String defaultCatalog) {
- this.defaultCatalog = defaultCatalog;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDefaultReadOnly(Boolean defaultReadOnly) {
- this.defaultReadOnly = defaultReadOnly;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDefaultTransactionIsolation(int defaultTransactionIsolation) {
- this.defaultTransactionIsolation = defaultTransactionIsolation;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setDriverClassName(String driverClassName) {
- this.driverClassName = driverClassName;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setInitialSize(int initialSize) {
- this.initialSize = initialSize;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setLogAbandoned(boolean logAbandoned) {
- this.logAbandoned = logAbandoned;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMaxActive(int maxActive) {
- this.maxActive = maxActive;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMaxIdle(int maxIdle) {
- this.maxIdle = maxIdle;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMaxWait(int maxWait) {
- this.maxWait = maxWait;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
- this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMinIdle(int minIdle) {
- this.minIdle = minIdle;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setName(String name) {
- this.name = name;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {
- this.numTestsPerEvictionRun = numTestsPerEvictionRun;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setPassword(String password) {
- this.password = password;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setRemoveAbandoned(boolean removeAbandoned) {
- this.removeAbandoned = removeAbandoned;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setRemoveAbandonedTimeout(int removeAbandonedTimeout) {
- this.removeAbandonedTimeout = removeAbandonedTimeout;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTestOnBorrow(boolean testOnBorrow) {
- this.testOnBorrow = testOnBorrow;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTestWhileIdle(boolean testWhileIdle) {
- this.testWhileIdle = testWhileIdle;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTestOnReturn(boolean testOnReturn) {
- this.testOnReturn = testOnReturn;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTimeBetweenEvictionRunsMillis(int
- timeBetweenEvictionRunsMillis) {
- this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setUrl(String url) {
- this.url = url;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setUsername(String username) {
- this.username = username;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setValidationInterval(long validationInterval) {
- this.validationInterval = validationInterval;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setValidationQuery(String validationQuery) {
- this.validationQuery = validationQuery;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setValidatorClassName(String className) {
- this.validatorClassName = className;
-
- validator = null;
-
- if (className == null) {
- return;
- }
-
- try {
- @SuppressWarnings("unchecked")
- Class<Validator> validatorClass = (Class<Validator>)ClassLoaderUtil.loadClass(
- className,
- PoolProperties.class.getClassLoader(),
- Thread.currentThread().getContextClassLoader()
- );
- validator = validatorClass.newInstance();
- } catch (ClassNotFoundException e) {
- log.warn("The class "+className+" cannot be found.", e);
- } catch (ClassCastException e) {
- log.warn("The class "+className+" does not implement the Validator interface.", e);
- } catch (InstantiationException e) {
- log.warn("An object of class "+className+" cannot be instantiated. Make sure that "+
- "it includes an implicit or explicit no-arg constructor.", e);
- } catch (IllegalAccessException e) {
- log.warn("The class "+className+" or its no-arg constructor are inaccessible.", e);
- }
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setInitSQL(String initSQL) {
- this.initSQL = initSQL!=null && initSQL.trim().length()>0 ? initSQL : null;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setTestOnConnect(boolean testOnConnect) {
- this.testOnConnect = testOnConnect;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setJdbcInterceptors(String jdbcInterceptors) {
- this.jdbcInterceptors = jdbcInterceptors;
- this.interceptors = null;
- }
-
-
- @Override
- public String toString() {
- StringBuilder buf = new StringBuilder("ConnectionPool[");
- try {
- String[] fields = DataSourceFactory.ALL_PROPERTIES;
- for (String field: fields) {
- final String[] prefix = new String[] {"get","is"};
- for (int j=0; j<prefix.length; j++) {
-
- String name = prefix[j]
- + field.substring(0, 1).toUpperCase(Locale.ENGLISH)
- + field.substring(1);
- Method m = null;
- try {
- m = getClass().getMethod(name);
- }catch (NoSuchMethodException nm) {
- continue;
- }
- buf.append(field);
- buf.append("=");
- if (DataSourceFactory.PROP_PASSWORD.equals(field)) {
- buf.append("********");
- } else {
- buf.append(m.invoke(this, new Object[0]));
- }
- buf.append("; ");
- break;
- }
- }
- }catch (Exception x) {
- //shouldn't happen
- log.debug("toString() call failed", x);
- }
- return buf.toString();
- }
-
- public static int getPoolCounter() {
- return poolCounter.get();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isJmxEnabled() {
- return jmxEnabled;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setJmxEnabled(boolean jmxEnabled) {
- this.jmxEnabled = jmxEnabled;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Boolean getDefaultAutoCommit() {
- return defaultAutoCommit;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Boolean getDefaultReadOnly() {
- return defaultReadOnly;
- }
-
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getSuspectTimeout() {
- return this.suspectTimeout;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setSuspectTimeout(int seconds) {
- this.suspectTimeout = seconds;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isPoolSweeperEnabled() {
- boolean timer = getTimeBetweenEvictionRunsMillis()>0;
- boolean result = timer && (isRemoveAbandoned() && getRemoveAbandonedTimeout()>0);
- result = result || (timer && getSuspectTimeout()>0);
- result = result || (timer && isTestWhileIdle() && getValidationQuery()!=null);
- result = result || (timer && getMinEvictableIdleTimeMillis()>0);
- return result;
- }
-
-
- public static class InterceptorDefinition implements Serializable {
- private static final long serialVersionUID = 1L;
- protected String className;
- protected Map<String,InterceptorProperty> properties = new HashMap<>();
- protected volatile Class<?> clazz = null;
- public InterceptorDefinition(String className) {
- this.className = className;
- }
-
- public InterceptorDefinition(Class<?> cl) {
- this(cl.getName());
- clazz = cl;
- }
-
- public String getClassName() {
- return className;
- }
- public void addProperty(String name, String value) {
- InterceptorProperty p = new InterceptorProperty(name,value);
- addProperty(p);
- }
-
- public void addProperty(InterceptorProperty p) {
- properties.put(p.getName(), p);
- }
-
- public Map<String,InterceptorProperty> getProperties() {
- return properties;
- }
-
- @SuppressWarnings("unchecked")
- public Class<? extends JdbcInterceptor> getInterceptorClass() throws ClassNotFoundException {
- if (clazz==null) {
- if (getClassName().indexOf('.')<0) {
- if (log.isDebugEnabled()) {
- log.debug("Loading interceptor class:"+PoolConfiguration.PKG_PREFIX+getClassName());
- }
- clazz = ClassLoaderUtil.loadClass(
- PoolConfiguration.PKG_PREFIX+getClassName(),
- PoolProperties.class.getClassLoader(),
- Thread.currentThread().getContextClassLoader()
- );
- } else {
- if (log.isDebugEnabled()) {
- log.debug("Loading interceptor class:"+getClassName());
- }
- clazz = ClassLoaderUtil.loadClass(
- getClassName(),
- PoolProperties.class.getClassLoader(),
- Thread.currentThread().getContextClassLoader()
- );
- }
- }
- return (Class<? extends JdbcInterceptor>)clazz;
- }
- }
-
- public static class InterceptorProperty implements Serializable {
- private static final long serialVersionUID = 1L;
- String name;
- String value;
- public InterceptorProperty(String name, String value) {
- assert(name!=null);
- this.name = name;
- this.value = value;
- }
- public String getName() {
- return name;
- }
- public String getValue() {
- return value;
- }
-
- public boolean getValueAsBoolean(boolean def) {
- if (value==null) return def;
- if ("true".equals(value)) return true;
- if ("false".equals(value)) return false;
- return def;
- }
-
- public int getValueAsInt(int def) {
- if (value==null) return def;
- try {
- int v = Integer.parseInt(value);
- return v;
- }catch (NumberFormatException nfe) {
- return def;
- }
- }
-
- public long getValueAsLong(long def) {
- if (value==null) return def;
- try {
- return Long.parseLong(value);
- }catch (NumberFormatException nfe) {
- return def;
- }
- }
-
- public byte getValueAsByte(byte def) {
- if (value==null) return def;
- try {
- return Byte.parseByte(value);
- }catch (NumberFormatException nfe) {
- return def;
- }
- }
-
- public short getValueAsShort(short def) {
- if (value==null) return def;
- try {
- return Short.parseShort(value);
- }catch (NumberFormatException nfe) {
- return def;
- }
- }
-
- public float getValueAsFloat(float def) {
- if (value==null) return def;
- try {
- return Float.parseFloat(value);
- }catch (NumberFormatException nfe) {
- return def;
- }
- }
-
- public double getValueAsDouble(double def) {
- if (value==null) return def;
- try {
- return Double.parseDouble(value);
- }catch (NumberFormatException nfe) {
- return def;
- }
- }
-
- public char getValueAschar(char def) {
- if (value==null) return def;
- try {
- return value.charAt(0);
- }catch (StringIndexOutOfBoundsException nfe) {
- return def;
- }
- }
-
- @Override
- public int hashCode() {
- return name.hashCode();
- }
-
- @Override
- public boolean equals(Object o) {
- if (o==this) return true;
- if (o instanceof InterceptorProperty) {
- InterceptorProperty other = (InterceptorProperty)o;
- return other.name.equals(this.name);
- }
- return false;
- }
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean isUseEquals() {
- return useEquals;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setUseEquals(boolean useEquals) {
- this.useEquals = useEquals;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public long getMaxAge() {
- return maxAge;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setMaxAge(long maxAge) {
- this.maxAge = maxAge;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public boolean getUseLock() {
- return useLock;
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setUseLock(boolean useLock) {
- this.useLock = useLock;
- }
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setDataSource(Object ds) {
- if (ds instanceof DataSourceProxy) {
- throw new IllegalArgumentException("Layered pools are not allowed.");
- }
- this.dataSource = ds;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Object getDataSource() {
- return dataSource;
- }
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setDataSourceJNDI(String jndiDS) {
- this.dataSourceJNDI = jndiDS;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public String getDataSourceJNDI() {
- return this.dataSourceJNDI;
- }
-
-
- public static Properties getProperties(String propText, Properties props) {
- if (props==null) props = new Properties();
- if (propText != null) {
- try {
- props.load(new ByteArrayInputStream(propText.replace(';', '\n').getBytes()));
- }catch (IOException x) {
- throw new RuntimeException(x);
- }
- }
- return props;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isAlternateUsernameAllowed() {
- return alternateUsernameAllowed;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setAlternateUsernameAllowed(boolean alternateUsernameAllowed) {
- this.alternateUsernameAllowed = alternateUsernameAllowed;
- }
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setCommitOnReturn(boolean commitOnReturn) {
- this.commitOnReturn = commitOnReturn;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getCommitOnReturn() {
- return this.commitOnReturn;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setRollbackOnReturn(boolean rollbackOnReturn) {
- this.rollbackOnReturn = rollbackOnReturn;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getRollbackOnReturn() {
- return this.rollbackOnReturn;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setUseDisposableConnectionFacade(boolean useDisposableConnectionFacade) {
- this.useDisposableConnectionFacade = useDisposableConnectionFacade;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getUseDisposableConnectionFacade() {
- return useDisposableConnectionFacade;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setLogValidationErrors(boolean logValidationErrors) {
- this.logValidationErrors = logValidationErrors;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getLogValidationErrors() {
- return this.logValidationErrors;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getPropagateInterruptState() {
- return propagateInterruptState;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setPropagateInterruptState(boolean propagateInterruptState) {
- this.propagateInterruptState = propagateInterruptState;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isIgnoreExceptionOnPreLoad() {
- return ignoreExceptionOnPreLoad;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setIgnoreExceptionOnPreLoad(boolean ignoreExceptionOnPreLoad) {
- this.ignoreExceptionOnPreLoad = ignoreExceptionOnPreLoad;
- }
-
- @Override
- protected Object clone() throws CloneNotSupportedException {
- // TODO Auto-generated method stub
- return super.clone();
- }
-
-
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.util.Properties;
-
-public class PoolUtilities {
-
- public static final String PROP_USER = "user";
-
- public static final String PROP_PASSWORD = "password";
-
- public static Properties clone(Properties p) {
- Properties c = new Properties();
- c.putAll(p);
- return c;
- }
-
- public static Properties cloneWithoutPassword(Properties p) {
- Properties result = clone(p);
- result.remove(PROP_PASSWORD);
- return result;
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.HashMap;
-import java.util.Properties;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;
-
-import com.mysql.jdbc.Driver;
-
-/**
- * Represents a pooled connection
- * and holds a reference to the {@link java.sql.Connection} object
- * @version 1.0
- */
-public class PooledConnection {
- /**
- * Logger
- */
- private static final Log log = LogFactory.getLog(PooledConnection.class);
-
- public static final String PROP_USER = PoolUtilities.PROP_USER;
-
- public static final String PROP_PASSWORD = PoolUtilities.PROP_PASSWORD;
-
- /**
- * Validate when connection is borrowed flag
- */
- public static final int VALIDATE_BORROW = 1;
- /**
- * Validate when connection is returned flag
- */
- public static final int VALIDATE_RETURN = 2;
- /**
- * Validate when connection is idle flag
- */
- public static final int VALIDATE_IDLE = 3;
- /**
- * Validate when connection is initialized flag
- */
- public static final int VALIDATE_INIT = 4;
- /**
- * The properties for the connection pool
- */
- protected PoolConfiguration poolProperties;
- /**
- * The underlying database connection
- */
- private volatile java.sql.Connection connection;
-
- /**
- * If using a XAConnection underneath.
- */
- protected volatile javax.sql.XAConnection xaConnection;
- /**
- * When we track abandon traces, this string holds the thread dump
- */
- private String abandonTrace = null;
- /**
- * Timestamp the connection was last 'touched' by the pool
- */
- private volatile long timestamp;
- /**
- * Lock for this connection only
- */
- private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(false);
- /**
- * Set to true if this connection has been discarded by the pool
- */
- private volatile boolean discarded = false;
- /**
- * The Timestamp when the last time the connect() method was called successfully
- */
- private volatile long lastConnected = -1;
- /**
- * timestamp to keep track of validation intervals
- */
- private volatile long lastValidated = System.currentTimeMillis();
- /**
- * The parent
- */
- protected ConnectionPool parent;
-
- private HashMap<Object, Object> attributes = new HashMap<>();
-
- private volatile long connectionVersion=0;
-
- /**
- * Weak reference to cache the list of interceptors for this connection
- * so that we don't create a new list of interceptors each time we borrow
- * the connection
- */
- private volatile JdbcInterceptor handler = null;
-
- private AtomicBoolean released = new AtomicBoolean(false);
-
- private volatile boolean suspect = false;
-
- private java.sql.Driver driver = null;
-
- /**
- * Constructor
- * @param prop - pool properties
- * @param parent - the parent connection pool
- */
- public PooledConnection(PoolConfiguration prop, ConnectionPool parent) {
- poolProperties = prop;
- this.parent = parent;
- connectionVersion = parent.getPoolVersion();
- }
-
- public long getConnectionVersion() {
- return connectionVersion;
- }
-
- /**
- * @deprecated use {@link #shouldForceReconnect(String, String)}
- * method kept since it was public, to avoid changing interface.
- * @param username The user name
- * @param password The password
- * @return <code>true</code>if the pool does not need to reconnect
- */
- @Deprecated
- public boolean checkUser(String username, String password) {
- return !shouldForceReconnect(username, password);
- }
-
- /**
- * Returns true if we must force reconnect based on credentials passed in.
- * Returns false if {@link PoolConfiguration#isAlternateUsernameAllowed()} method returns false.
- * Returns false if the username/password has not changed since this connection was connected
- * @param username the username you wish to connect with, pass in null to accept the default username from {@link PoolConfiguration#getUsername()}
- * @param password the password you wish to connect with, pass in null to accept the default username from {@link org.apache.tomcat.jdbc.pool.PoolConfiguration#getPassword()}
- * @return true is the pool must reconnect
- */
- public boolean shouldForceReconnect(String username, String password) {
-
- if (!getPoolProperties().isAlternateUsernameAllowed()) return false;
-
- if (username==null) username = poolProperties.getUsername();
- if (password==null) password = poolProperties.getPassword();
-
- String storedUsr = (String)getAttributes().get(PROP_USER);
- String storedPwd = (String)getAttributes().get(PROP_PASSWORD);
-
- boolean noChangeInCredentials = (username==null && storedUsr==null);
- noChangeInCredentials = (noChangeInCredentials || (username!=null && username.equals(storedUsr)));
-
- noChangeInCredentials = noChangeInCredentials && ((password==null && storedPwd==null) || (password!=null && password.equals(storedPwd)));
-
- if (username==null) getAttributes().remove(PROP_USER); else getAttributes().put(PROP_USER, username);
- if (password==null) getAttributes().remove(PROP_PASSWORD); else getAttributes().put(PROP_PASSWORD, password);
-
- return !noChangeInCredentials;
- }
-
- /**
- * Connects the underlying connection to the database.
- * @throws SQLException if the method {@link #release()} has been called.
- * @throws SQLException if driver instantiation fails
- * @throws SQLException if a call to {@link java.sql.Driver#connect(String, java.util.Properties)} fails.
- * @throws SQLException if default properties are configured and a call to
- * {@link java.sql.Connection#setAutoCommit(boolean)}, {@link java.sql.Connection#setCatalog(String)},
- * {@link java.sql.Connection#setTransactionIsolation(int)} or {@link java.sql.Connection#setReadOnly(boolean)} fails.
- */
- public void connect() throws SQLException {
- if (released.get()) throw new SQLException("A connection once released, can't be reestablished.");
- if (connection != null) {
- try {
- this.disconnect(false);
- } catch (Exception x) {
- log.debug("Unable to disconnect previous connection.", x);
- } //catch
- } //end if
- if (poolProperties.getDataSource()==null && poolProperties.getDataSourceJNDI()!=null) {
- //TODO lookup JNDI name
- }
-
- if (poolProperties.getDataSource()!=null) {
- connectUsingDataSource();
- } else {
- connectUsingDriver();
- }
-
- //set up the default state, unless we expect the interceptor to do it
- if (poolProperties.getJdbcInterceptors()==null || poolProperties.getJdbcInterceptors().indexOf(ConnectionState.class.getName())<0 ||
- poolProperties.getJdbcInterceptors().indexOf(ConnectionState.class.getSimpleName())<0) {
- if (poolProperties.getDefaultTransactionIsolation()!=DataSourceFactory.UNKNOWN_TRANSACTIONISOLATION) connection.setTransactionIsolation(poolProperties.getDefaultTransactionIsolation());
- if (poolProperties.getDefaultReadOnly()!=null) connection.setReadOnly(poolProperties.getDefaultReadOnly().booleanValue());
- if (poolProperties.getDefaultAutoCommit()!=null) connection.setAutoCommit(poolProperties.getDefaultAutoCommit().booleanValue());
- if (poolProperties.getDefaultCatalog()!=null) connection.setCatalog(poolProperties.getDefaultCatalog());
- }
- this.discarded = false;
- this.lastConnected = System.currentTimeMillis();
- }
-
- protected void connectUsingDataSource() throws SQLException {
- String usr = null;
- String pwd = null;
- if (getAttributes().containsKey(PROP_USER)) {
- usr = (String) getAttributes().get(PROP_USER);
- } else {
- usr = poolProperties.getUsername();
- getAttributes().put(PROP_USER, usr);
- }
- if (getAttributes().containsKey(PROP_PASSWORD)) {
- pwd = (String) getAttributes().get(PROP_PASSWORD);
- } else {
- pwd = poolProperties.getPassword();
- getAttributes().put(PROP_PASSWORD, pwd);
- }
- if (poolProperties.getDataSource() instanceof javax.sql.XADataSource) {
- javax.sql.XADataSource xds = (javax.sql.XADataSource)poolProperties.getDataSource();
- if (usr!=null && pwd!=null) {
- xaConnection = xds.getXAConnection(usr, pwd);
- connection = xaConnection.getConnection();
- } else {
- xaConnection = xds.getXAConnection();
- connection = xaConnection.getConnection();
- }
- } else if (poolProperties.getDataSource() instanceof javax.sql.DataSource){
- javax.sql.DataSource ds = (javax.sql.DataSource)poolProperties.getDataSource();
- if (usr!=null && pwd!=null) {
- connection = ds.getConnection(usr, pwd);
- } else {
- connection = ds.getConnection();
- }
- } else if (poolProperties.getDataSource() instanceof javax.sql.ConnectionPoolDataSource){
- javax.sql.ConnectionPoolDataSource ds = (javax.sql.ConnectionPoolDataSource)poolProperties.getDataSource();
- if (usr!=null && pwd!=null) {
- connection = ds.getPooledConnection(usr, pwd).getConnection();
- } else {
- connection = ds.getPooledConnection().getConnection();
- }
- } else {
- throw new SQLException("DataSource is of unknown class:"+(poolProperties.getDataSource()!=null?poolProperties.getDataSource().getClass():"null"));
- }
- }
- protected void connectUsingDriver() throws SQLException {
-
- try {
- Class.forName("com.mysql.jdbc.Driver") ;
- Driver dr = new com.mysql.jdbc.Driver();
- if(dr == null)
- log.warn("Driver NOT CREATED");
- } catch (ClassNotFoundException e) {
- log.warn("Driver NOT CREATED", e);
- }
-
- try {
- if (driver==null) {
- if (log.isDebugEnabled()) {
- log.debug("Instantiating driver using class: "+poolProperties.getDriverClassName()+" [url="+poolProperties.getUrl()+"]");
- }
- if (poolProperties.getDriverClassName()==null) {
- //rely on DriverManager
- log.warn("Not loading a JDBC driver as driverClassName property is null.");
- } else {
- driver = (java.sql.Driver)
- ClassLoaderUtil.loadClass(
- poolProperties.getDriverClassName(),
- PooledConnection.class.getClassLoader(),
- Thread.currentThread().getContextClassLoader()
- ).newInstance();
- }
- }
- } catch (java.lang.Exception cn) {
- if (log.isDebugEnabled()) {
- log.debug("Unable to instantiate JDBC driver.", cn);
- }
- SQLException ex = new SQLException(cn.getMessage());
- ex.initCause(cn);
- throw ex;
- }
- String driverURL = poolProperties.getUrl();
- String usr = null;
- String pwd = null;
- if (getAttributes().containsKey(PROP_USER)) {
- usr = (String) getAttributes().get(PROP_USER);
- } else {
- usr = poolProperties.getUsername();
- getAttributes().put(PROP_USER, usr);
- }
- if (getAttributes().containsKey(PROP_PASSWORD)) {
- pwd = (String) getAttributes().get(PROP_PASSWORD);
- } else {
- pwd = poolProperties.getPassword();
- getAttributes().put(PROP_PASSWORD, pwd);
- }
- Properties properties = PoolUtilities.clone(poolProperties.getDbProperties());
- if (usr != null) properties.setProperty(PROP_USER, usr);
- if (pwd != null) properties.setProperty(PROP_PASSWORD, pwd);
-
- try {
- if (driver==null) {
- connection = DriverManager.getConnection(driverURL, properties);
- } else {
- connection = driver.connect(driverURL, properties);
- }
- } catch (Exception x) {
- if (log.isDebugEnabled()) {
- log.debug("Unable to connect to database.", x);
- }
- if (parent.jmxPool!=null) {
- parent.jmxPool.notify(org.apache.tomcat.jdbc.pool.jmx.ConnectionPool.NOTIFY_CONNECT,
- ConnectionPool.getStackTrace(x));
- }
- if (x instanceof SQLException) {
- throw (SQLException)x;
- } else {
- SQLException ex = new SQLException(x.getMessage());
- ex.initCause(x);
- throw ex;
- }
- }
- if (connection==null) {
- throw new SQLException("Driver:"+driver+" returned null for URL:"+driverURL);
- }
- }
-
- /**
- *
- * @return true if connect() was called successfully and disconnect has not yet been called
- */
- public boolean isInitialized() {
- return connection!=null;
- }
-
- /**
- * Returns true if the connection has been connected more than
- * {@link PoolConfiguration#getMaxAge()} milliseconds. false otherwise.
- * @return Returns true if the connection has been connected more than
- * {@link PoolConfiguration#getMaxAge()} milliseconds. false otherwise.
- */
- public boolean isMaxAgeExpired() {
- if (getPoolProperties().getMaxAge()>0 ) {
- return (System.currentTimeMillis() - getLastConnected()) > getPoolProperties().getMaxAge();
- } else {
- return false;
- }
- }
- /**
- * Issues a call to {@link #disconnect(boolean)} with the argument false followed by a call to
- * {@link #connect()}
- * @throws SQLException if the call to {@link #connect()} fails.
- */
- public void reconnect() throws SQLException {
- this.disconnect(false);
- this.connect();
- } //reconnect
-
- /**
- * Disconnects the connection. All exceptions are logged using debug level.
- * @param finalize if set to true, a call to {@link ConnectionPool#finalize(PooledConnection)} is called.
- */
- private void disconnect(boolean finalize) {
- if (isDiscarded() && connection == null) {
- return;
- }
- setDiscarded(true);
- if (connection != null) {
- try {
- parent.disconnectEvent(this, finalize);
- if (xaConnection == null) {
- connection.close();
- } else {
- xaConnection.close();
- }
- }catch (Exception ignore) {
- if (log.isDebugEnabled()) {
- log.debug("Unable to close underlying SQL connection",ignore);
- }
- }
- }
- connection = null;
- xaConnection = null;
- lastConnected = -1;
- if (finalize) parent.finalize(this);
- }
-
-
-//============================================================================
-//
-//============================================================================
-
- /**
- * Returns abandon timeout in milliseconds
- * @return abandon timeout in milliseconds
- */
- public long getAbandonTimeout() {
- if (poolProperties.getRemoveAbandonedTimeout() <= 0) {
- return Long.MAX_VALUE;
- } else {
- return poolProperties.getRemoveAbandonedTimeout() * 1000L;
- } //end if
- }
-
- /**
- * Returns <code>true</code> if the connection pool is configured
- * to do validation for a certain action.
- * @param action The validation action
- */
- private boolean doValidate(int action) {
- if (action == PooledConnection.VALIDATE_BORROW &&
- poolProperties.isTestOnBorrow())
- return true;
- else if (action == PooledConnection.VALIDATE_RETURN &&
- poolProperties.isTestOnReturn())
- return true;
- else if (action == PooledConnection.VALIDATE_IDLE &&
- poolProperties.isTestWhileIdle())
- return true;
- else if (action == PooledConnection.VALIDATE_INIT &&
- poolProperties.isTestOnConnect())
- return true;
- else if (action == PooledConnection.VALIDATE_INIT &&
- poolProperties.getInitSQL()!=null)
- return true;
- else
- return false;
- }
-
- /**
- * Returns <code>true</code> if the object is still valid. if not
- * the pool will call the getExpiredAction() and follow up with one
- * of the four expired methods
- * @param validateAction The value
- * @return <code>true</code> if the connection is valid
- */
- public boolean validate(int validateAction) {
- return validate(validateAction,null);
- }
-
- /**
- * Validates a connection.
- * @param validateAction the action used. One of {@link #VALIDATE_BORROW}, {@link #VALIDATE_IDLE},
- * {@link #VALIDATE_INIT} or {@link #VALIDATE_RETURN}
- * @param sql the SQL to be used during validation. If the {@link PoolConfiguration#setInitSQL(String)} has been called with a non null
- * value and the action is {@link #VALIDATE_INIT} the init SQL will be used for validation.
- *
- * @return true if the connection was validated successfully. It returns true even if validation was not performed, such as when
- * {@link PoolConfiguration#setValidationInterval(long)} has been called with a positive value.
- * <p>
- * false if the validation failed. The caller should close the connection if false is returned since a session could have been left in
- * an unknown state during initialization.
- */
- public boolean validate(int validateAction,String sql) {
- if (this.isDiscarded()) {
- return false;
- }
-
- if (!doValidate(validateAction)) {
- //no validation required, no init sql and props not set
- return true;
- }
-
- //Don't bother validating if already have recently enough
- long now = System.currentTimeMillis();
- if (validateAction!=VALIDATE_INIT &&
- poolProperties.getValidationInterval() > 0 &&
- (now - this.lastValidated) <
- poolProperties.getValidationInterval()) {
- return true;
- }
-
- if (poolProperties.getValidator() != null) {
- if (poolProperties.getValidator().validate(connection, validateAction)) {
- this.lastValidated = now;
- return true;
- } else {
- if (getPoolProperties().getLogValidationErrors()) {
- log.error("Custom validation through "+poolProperties.getValidator()+" failed.");
- }
- return false;
- }
- }
-
- String query = sql;
-
- if (validateAction == VALIDATE_INIT && poolProperties.getInitSQL() != null) {
- query = poolProperties.getInitSQL();
- }
-
- if (query == null) {
- query = poolProperties.getValidationQuery();
- }
-
- if (query == null) {
- int validationQueryTimeout = poolProperties.getValidationQueryTimeout();
- if (validationQueryTimeout < 0) validationQueryTimeout = 0;
- try {
- if (connection.isValid(validationQueryTimeout)) {
- this.lastValidated = now;
- return true;
- } else {
- if (getPoolProperties().getLogValidationErrors()) {
- log.error("isValid() returned false.");
- }
- return false;
- }
- } catch (SQLException e) {
- if (getPoolProperties().getLogValidationErrors()) {
- log.error("isValid() failed.", e);
- } else if (log.isDebugEnabled()) {
- log.debug("isValid() failed.", e);
- }
- return false;
- }
- }
-
- Statement stmt = null;
- try {
- stmt = connection.createStatement();
-
- int validationQueryTimeout = poolProperties.getValidationQueryTimeout();
- if (validationQueryTimeout > 0) {
- stmt.setQueryTimeout(validationQueryTimeout);
- }
-
- stmt.execute(query);
- stmt.close();
- this.lastValidated = now;
- return true;
- } catch (Exception ex) {
- if (getPoolProperties().getLogValidationErrors()) {
- log.warn("SQL Validation error", ex);
- } else if (log.isDebugEnabled()) {
- log.debug("Unable to validate object:",ex);
- }
- if (stmt!=null)
- try { stmt.close();} catch (Exception ignore2){/*NOOP*/}
- }
- return false;
- } //validate
-
- /**
- * The time limit for how long the object
- * can remain unused before it is released
- * @return {@link PoolConfiguration#getMinEvictableIdleTimeMillis()}
- */
- public long getReleaseTime() {
- return this.poolProperties.getMinEvictableIdleTimeMillis();
- }
-
- /**
- * This method is called if (Now - timeCheckedIn > getReleaseTime())
- * This method disconnects the connection, logs an error in debug mode if it happens
- * then sets the {@link #released} flag to false. Any attempts to connect this cached object again
- * will fail per {@link #connect()}
- * The connection pool uses the atomic return value to decrement the pool size counter.
- * @return true if this is the first time this method has been called. false if this method has been called before.
- */
- public boolean release() {
- try {
- disconnect(true);
- } catch (Exception x) {
- if (log.isDebugEnabled()) {
- log.debug("Unable to close SQL connection",x);
- }
- }
- return released.compareAndSet(false, true);
-
- }
-
- /**
- * The pool will set the stack trace when it is check out and
- * checked in
- * @param trace the stack trace for this connection
- */
-
- public void setStackTrace(String trace) {
- abandonTrace = trace;
- }
-
- /**
- * Returns the stack trace from when this connection was borrowed. Can return null if no stack trace was set.
- * @return the stack trace or null of no trace was set
- */
- public String getStackTrace() {
- return abandonTrace;
- }
-
- /**
- * Sets a timestamp on this connection. A timestamp usually means that some operation
- * performed successfully.
- * @param timestamp the timestamp as defined by {@link System#currentTimeMillis()}
- */
- public void setTimestamp(long timestamp) {
- this.timestamp = timestamp;
- setSuspect(false);
- }
-
-
- public boolean isSuspect() {
- return suspect;
- }
-
- public void setSuspect(boolean suspect) {
- this.suspect = suspect;
- }
-
- /**
- * An interceptor can call this method with the value true, and the connection will be closed when it is returned to the pool.
- * @param discarded - only valid value is true
- * @throws IllegalStateException if this method is called with the value false and the value true has already been set.
- */
- public void setDiscarded(boolean discarded) {
- if (this.discarded && !discarded) throw new IllegalStateException("Unable to change the state once the connection has been discarded");
- this.discarded = discarded;
- }
-
- /**
- * Set the timestamp the connection was last validated.
- * This flag is used to keep track when we are using a {@link PoolConfiguration#setValidationInterval(long) validation-interval}.
- * @param lastValidated a timestamp as defined by {@link System#currentTimeMillis()}
- */
- public void setLastValidated(long lastValidated) {
- this.lastValidated = lastValidated;
- }
-
- /**
- * Sets the pool configuration for this connection and connection pool.
- * Object is shared with the {@link ConnectionPool}
- * @param poolProperties The pool properties
- */
- public void setPoolProperties(PoolConfiguration poolProperties) {
- this.poolProperties = poolProperties;
- }
-
- /**
- * Return the timestamps of last pool action. Timestamps are typically set when connections
- * are borrowed from the pool. It is used to keep track of {@link PoolConfiguration#setRemoveAbandonedTimeout(int) abandon-timeouts}.
- * This timestamp can also be reset by the {@link org.apache.tomcat.jdbc.pool.interceptor.ResetAbandonedTimer#invoke(Object, java.lang.reflect.Method, Object[])}
- * @return the timestamp of the last pool action as defined by {@link System#currentTimeMillis()}
- */
- public long getTimestamp() {
- return timestamp;
- }
-
- /**
- * Returns the discarded flag.
- * @return the discarded flag. If the value is true,
- * either {@link #disconnect(boolean)} has been called or it will be called when the connection is returned to the pool.
- */
- public boolean isDiscarded() {
- return discarded;
- }
-
- /**
- * Returns the timestamp of the last successful validation query execution.
- * @return the timestamp of the last successful validation query execution as defined by {@link System#currentTimeMillis()}
- */
- public long getLastValidated() {
- return lastValidated;
- }
-
- /**
- * Returns the configuration for this connection and pool
- * @return the configuration for this connection and pool
- */
- public PoolConfiguration getPoolProperties() {
- return poolProperties;
- }
-
- /**
- * Locks the connection only if either {@link PoolConfiguration#isPoolSweeperEnabled()} or
- * {@link PoolConfiguration#getUseLock()} return true. The per connection lock ensures thread safety is
- * multiple threads are performing operations on the connection.
- * Otherwise this is a noop for performance
- */
- public void lock() {
- if (poolProperties.getUseLock() || this.poolProperties.isPoolSweeperEnabled()) {
- //optimized, only use a lock when there is concurrency
- lock.writeLock().lock();
- }
- }
-
- /**
- * Unlocks the connection only if the sweeper is enabled
- * Otherwise this is a noop for performance
- */
- public void unlock() {
- if (poolProperties.getUseLock() || this.poolProperties.isPoolSweeperEnabled()) {
- //optimized, only use a lock when there is concurrency
- lock.writeLock().unlock();
- }
- }
-
- /**
- * Returns the underlying connection
- * @return the underlying JDBC connection as it was returned from the JDBC driver
- * @see javax.sql.PooledConnection#getConnection()
- */
- public java.sql.Connection getConnection() {
- return this.connection;
- }
-
- /**
- * Returns the underlying XA connection
- * @return the underlying XA connection as it was returned from the Datasource
- */
- public javax.sql.XAConnection getXAConnection() {
- return this.xaConnection;
- }
-
-
- /**
- * Returns the timestamp of when the connection was last connected to the database.
- * ie, a successful call to {@link java.sql.Driver#connect(String, java.util.Properties)}.
- * @return the timestamp when this connection was created as defined by {@link System#currentTimeMillis()}
- */
- public long getLastConnected() {
- return lastConnected;
- }
-
- /**
- * Returns the first handler in the interceptor chain
- * @return the first interceptor for this connection
- */
- public JdbcInterceptor getHandler() {
- return handler;
- }
-
- public void setHandler(JdbcInterceptor handler) {
- if (this.handler!=null && this.handler!=handler) {
- JdbcInterceptor interceptor = this.handler;
- while (interceptor!=null) {
- interceptor.reset(null, null);
- interceptor = interceptor.getNext();
- }//while
- }//end if
- this.handler = handler;
- }
-
- @Override
- public String toString() {
- return "PooledConnection["+(connection!=null?connection.toString():"null")+"]";
- }
-
- /**
- * Returns true if this connection has been released and wont be reused.
- * @return true if the method {@link #release()} has been called
- */
- public boolean isReleased() {
- return released.get();
- }
-
- public HashMap<Object,Object> getAttributes() {
- return attributes;
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.sql.SQLException;
-
-import javax.sql.XAConnection;
-/**
- * A ProxyConnection object is the bottom most interceptor that wraps an object of type
- * {@link PooledConnection}. The ProxyConnection intercepts three methods:
- * <ul>
- * <li>{@link java.sql.Connection#close()} - returns the connection to the pool. May be called multiple times.</li>
- * <li>{@link java.lang.Object#toString()} - returns a custom string for this object</li>
- * <li>{@link javax.sql.PooledConnection#getConnection()} - returns the underlying connection</li>
- * </ul>
- * By default method comparisons is done on a String reference level, unless the {@link PoolConfiguration#setUseEquals(boolean)} has been called
- * with a <code>true</code> argument.
- */
-public class ProxyConnection extends JdbcInterceptor {
-
- protected PooledConnection connection = null;
-
- protected ConnectionPool pool = null;
-
- public PooledConnection getConnection() {
- return connection;
- }
-
- public void setConnection(PooledConnection connection) {
- this.connection = connection;
- }
-
- public ConnectionPool getPool() {
- return pool;
- }
-
- public void setPool(ConnectionPool pool) {
- this.pool = pool;
- }
-
- protected ProxyConnection(ConnectionPool parent, PooledConnection con,
- boolean useEquals) {
- pool = parent;
- connection = con;
- setUseEquals(useEquals);
- }
-
- @Override
- public void reset(ConnectionPool parent, PooledConnection con) {
- this.pool = parent;
- this.connection = con;
- }
-
- public boolean isWrapperFor(Class<?> iface) {
- if (iface == XAConnection.class && connection.getXAConnection()!=null) {
- return true;
- } else {
- return (iface.isInstance(connection.getConnection()));
- }
- }
-
-
- public Object unwrap(Class<?> iface) throws SQLException {
- if (iface == PooledConnection.class) {
- return connection;
- }else if (iface == XAConnection.class) {
- return connection.getXAConnection();
- } else if (isWrapperFor(iface)) {
- return connection.getConnection();
- } else {
- throw new SQLException("Not a wrapper of "+iface.getName());
- }
- }
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- if (compare(ISCLOSED_VAL,method)) {
- return Boolean.valueOf(isClosed());
- }
- if (compare(CLOSE_VAL,method)) {
- if (connection==null) return null; //noop for already closed.
- PooledConnection poolc = this.connection;
- this.connection = null;
- pool.returnConnection(poolc);
- return null;
- } else if (compare(TOSTRING_VAL,method)) {
- return this.toString();
- } else if (compare(GETCONNECTION_VAL,method) && connection!=null) {
- return connection.getConnection();
- } else if (method.getDeclaringClass().equals(XAConnection.class)) {
- try {
- return method.invoke(connection.getXAConnection(),args);
- }catch (Throwable t) {
- if (t instanceof InvocationTargetException) {
- throw t.getCause() != null ? t.getCause() : t;
- } else {
- throw t;
- }
- }
- }
- if (isClosed()) throw new SQLException("Connection has already been closed.");
- if (compare(UNWRAP_VAL,method)) {
- return unwrap((Class<?>)args[0]);
- } else if (compare(ISWRAPPERFOR_VAL,method)) {
- return Boolean.valueOf(this.isWrapperFor((Class<?>)args[0]));
- }
- try {
- PooledConnection poolc = connection;
- if (poolc!=null) {
- return method.invoke(poolc.getConnection(),args);
- } else {
- throw new SQLException("Connection has already been closed.");
- }
- }catch (Throwable t) {
- if (t instanceof InvocationTargetException) {
- throw t.getCause() != null ? t.getCause() : t;
- } else {
- throw t;
- }
- }
- }
-
- public boolean isClosed() {
- return connection==null || connection.isDiscarded();
- }
-
- public PooledConnection getDelegateConnection() {
- return connection;
- }
-
- public ConnectionPool getParentPool() {
- return pool;
- }
-
- @Override
- public String toString() {
- return "ProxyConnection["+(connection!=null?connection.toString():"null")+"]";
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.tomcat.jdbc.pool;
-
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.sql.SQLException;
-/**
- * Interceptor that traps any unhandled exception types and throws an exception that has been declared by the method
- * called, or throw a SQLException if it is declared.
- * If the caught exception is not declared, and the method doesn't throw SQLException, then this interceptor will
- * throw a RuntimeException
- *
- */
-public class TrapException extends JdbcInterceptor {
-
-
- public TrapException() {
- }
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- try {
- return super.invoke(proxy, method, args);
- }catch (Exception t) {
- Throwable exception = t;
- if (t instanceof InvocationTargetException && t.getCause() != null) {
- exception = t.getCause();
- if (exception instanceof Error) {
- throw exception;
- }
- }
- Class<?> exceptionClass = exception.getClass();
- if (!isDeclaredException(method, exceptionClass)) {
- if (isDeclaredException(method,SQLException.class)) {
- SQLException sqlx = new SQLException("Uncaught underlying exception.");
- sqlx.initCause(exception);
- exception = sqlx;
- } else {
- RuntimeException rx = new RuntimeException("Uncaught underlying exception.");
- rx.initCause(exception);
- exception = rx;
- }
- }
- throw exception;
- }
-
- }
-
- public boolean isDeclaredException(Method m, Class<?> clazz) {
- for (Class<?> cl : m.getExceptionTypes()) {
- if (cl.equals(clazz) || cl.isAssignableFrom(clazz)) return true;
- }
- return false;
- }
-
- /**
- * no-op for this interceptor. no state is stored.
- */
- @Override
- public void reset(ConnectionPool parent, PooledConnection con) {
- // NOOP
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool;
-
-import java.sql.Connection;
-
-/**
- * Interface to be implemented by custom validator classes.
- *
- * @author mpassell
- */
-public interface Validator {
- /**
- * Validate a connection and return a boolean to indicate if it's valid.
- *
- * @param connection the Connection object to test
- * @param validateAction the action used. One of {@link PooledConnection#VALIDATE_BORROW},
- * {@link PooledConnection#VALIDATE_IDLE}, {@link PooledConnection#VALIDATE_INIT} or
- * {@link PooledConnection#VALIDATE_RETURN}
- * @return true if the connection is valid
- */
- public boolean validate(Connection connection, int validateAction);
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.tomcat.jdbc.pool;
-
-public class XADataSource extends DataSource implements javax.sql.XADataSource {
-
- /**
- * Constructor for reflection only. A default set of pool properties will be created.
- */
- public XADataSource() {
- super();
- }
-
- /**
- * Constructs a DataSource object wrapping a connection
- * @param poolProperties The pool configuration
- */
- public XADataSource(PoolConfiguration poolProperties) {
- super(poolProperties);
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.lang.reflect.Method;
-
-import org.apache.tomcat.jdbc.pool.ConnectionPool;
-import org.apache.tomcat.jdbc.pool.JdbcInterceptor;
-import org.apache.tomcat.jdbc.pool.PooledConnection;
-
-/**
- * Abstraction interceptor. This component intercepts all calls to create some type of SQL statement.
- * By extending this class, one can intercept queries and update statements by overriding the {@link #createStatement(Object, Method, Object[], Object, long)}
- * method.
- * @version 1.0
- */
-public abstract class AbstractCreateStatementInterceptor extends JdbcInterceptor {
- protected static final String CREATE_STATEMENT = "createStatement";
- protected static final int CREATE_STATEMENT_IDX = 0;
- protected static final String PREPARE_STATEMENT = "prepareStatement";
- protected static final int PREPARE_STATEMENT_IDX = 1;
- protected static final String PREPARE_CALL = "prepareCall";
- protected static final int PREPARE_CALL_IDX = 2;
-
- protected static final String[] STATEMENT_TYPES = {CREATE_STATEMENT, PREPARE_STATEMENT, PREPARE_CALL};
- protected static final int STATEMENT_TYPE_COUNT = STATEMENT_TYPES.length;
-
- protected static final String EXECUTE = "execute";
- protected static final String EXECUTE_QUERY = "executeQuery";
- protected static final String EXECUTE_UPDATE = "executeUpdate";
- protected static final String EXECUTE_BATCH = "executeBatch";
-
- protected static final String[] EXECUTE_TYPES = {EXECUTE, EXECUTE_QUERY, EXECUTE_UPDATE, EXECUTE_BATCH};
-
- public AbstractCreateStatementInterceptor() {
- super();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- if (compare(CLOSE_VAL,method)) {
- closeInvoked();
- return super.invoke(proxy, method, args);
- } else {
- boolean process = false;
- process = isStatement(method, process);
- if (process) {
- long start = System.currentTimeMillis();
- Object statement = super.invoke(proxy,method,args);
- long delta = System.currentTimeMillis() - start;
- return createStatement(proxy,method,args,statement, delta);
- } else {
- return super.invoke(proxy,method,args);
- }
- }
- }
-
- /**
- * This method will be invoked after a successful statement creation. This method can choose to return a wrapper
- * around the statement or return the statement itself.
- * If this method returns a wrapper then it should return a wrapper object that implements one of the following interfaces.
- * {@link java.sql.Statement}, {@link java.sql.PreparedStatement} or {@link java.sql.CallableStatement}
- * @param proxy the actual proxy object
- * @param method the method that was called. It will be one of the methods defined in {@link #STATEMENT_TYPES}
- * @param args the arguments to the method
- * @param statement the statement that the underlying connection created
- * @param time Elapsed time
- * @return a {@link java.sql.Statement} object
- */
- public abstract Object createStatement(Object proxy, Method method, Object[] args, Object statement, long time);
-
- /**
- * Method invoked when the operation {@link java.sql.Connection#close()} is invoked.
- */
- public abstract void closeInvoked();
-
- /**
- * Returns true if the method that is being invoked matches one of the statement types.
- *
- * @param method the method being invoked on the proxy
- * @param process boolean result used for recursion
- * @return returns true if the method name matched
- */
- protected boolean isStatement(Method method, boolean process){
- return process(STATEMENT_TYPES, method, process);
- }
-
- /**
- * Returns true if the method that is being invoked matches one of the execute types.
- *
- * @param method the method being invoked on the proxy
- * @param process boolean result used for recursion
- * @return returns true if the method name matched
- */
- protected boolean isExecute(Method method, boolean process){
- return process(EXECUTE_TYPES, method, process);
- }
-
- /*
- * Returns true if the method that is being invoked matches one of the method names passed in
- * @param names list of method names that we want to intercept
- * @param method the method being invoked on the proxy
- * @param process boolean result used for recursion
- * @return returns true if the method name matched
- */
- protected boolean process(String[] names, Method method, boolean process) {
- final String name = method.getName();
- for (int i=0; (!process) && i<names.length; i++) {
- process = compare(names[i],name);
- }
- return process;
- }
-
- /**
- * no-op for this interceptor. no state is stored.
- */
- @Override
- public void reset(ConnectionPool parent, PooledConnection con) {
- // NOOP
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.sql.CallableStatement;
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.JdbcInterceptor;
-/**
- * Abstract class that wraps statements and intercepts query executions.
- *
- */
-public abstract class AbstractQueryReport extends AbstractCreateStatementInterceptor {
- //logger
- private static final Log log = LogFactory.getLog(AbstractQueryReport.class);
-
- /**
- * The threshold in milliseconds. If the query is faster than this, we don't measure it
- */
- protected long threshold = 1000; //don't report queries less than this
-
- /**
- * the constructors that are used to create statement proxies
- */
- protected static final Constructor<?>[] constructors =
- new Constructor[AbstractCreateStatementInterceptor.STATEMENT_TYPE_COUNT];
-
-
- public AbstractQueryReport() {
- super();
- }
-
- /**
- * Invoked when prepareStatement has been called and completed.
- * @param sql - the string used to prepare the statement with
- * @param time - the time it took to invoke prepare
- */
- protected abstract void prepareStatement(String sql, long time);
-
- /**
- * Invoked when prepareCall has been called and completed.
- * @param query - the string used to prepare the statement with
- * @param time - the time it took to invoke prepare
- */
- protected abstract void prepareCall(String query, long time);
-
- /**
- * Invoked when a query execution, a call to execute/executeQuery or executeBatch failed.
- * @param query the query that was executed and failed
- * @param args the arguments to the execution
- * @param name the name of the method used to execute {@link AbstractCreateStatementInterceptor#isExecute(Method, boolean)}
- * @param start the time the query execution started
- * @param t the exception that happened
- * @return - the SQL that was executed or the string "batch" if it was a batch execution
- */
- protected String reportFailedQuery(String query, Object[] args, final String name, long start, Throwable t) {
- //extract the query string
- String sql = (query==null && args!=null && args.length>0)?(String)args[0]:query;
- //if we do batch execution, then we name the query 'batch'
- if (sql==null && compare(EXECUTE_BATCH,name)) {
- sql = "batch";
- }
- return sql;
- }
-
- /**
- * Invoked when a query execution, a call to execute/executeQuery or executeBatch succeeded and was within the timing threshold
- * @param query the query that was executed and failed
- * @param args the arguments to the execution
- * @param name the name of the method used to execute {@link AbstractCreateStatementInterceptor#isExecute(Method, boolean)}
- * @param start the time the query execution started
- * @param delta the time the execution took
- * @return - the SQL that was executed or the string "batch" if it was a batch execution
- */
- protected String reportQuery(String query, Object[] args, final String name, long start, long delta) {
- //extract the query string
- String sql = (query==null && args!=null && args.length>0)?(String)args[0]:query;
- //if we do batch execution, then we name the query 'batch'
- if (sql==null && compare(EXECUTE_BATCH,name)) {
- sql = "batch";
- }
- return sql;
- }
-
- /**
- * Invoked when a query execution, a call to execute/executeQuery or executeBatch succeeded and was exceeded the timing threshold
- * @param query the query that was executed and failed
- * @param args the arguments to the execution
- * @param name the name of the method used to execute {@link AbstractCreateStatementInterceptor#isExecute(Method, boolean)}
- * @param start the time the query execution started
- * @param delta the time the execution took
- * @return - the SQL that was executed or the string "batch" if it was a batch execution
- */
- protected String reportSlowQuery(String query, Object[] args, final String name, long start, long delta) {
- //extract the query string
- String sql = (query==null && args!=null && args.length>0)?(String)args[0]:query;
- //if we do batch execution, then we name the query 'batch'
- if (sql==null && compare(EXECUTE_BATCH,name)) {
- sql = "batch";
- }
- return sql;
- }
-
- /**
- * returns the query measure threshold.
- * This value is in milliseconds. If the query is faster than this threshold than it wont be accounted for
- * @return the threshold in milliseconds
- */
- public long getThreshold() {
- return threshold;
- }
-
- /**
- * Sets the query measurement threshold. The value is in milliseconds.
- * If the query goes faster than this threshold it will not be recorded.
- * @param threshold set to -1 to record every query. Value is in milliseconds.
- */
- public void setThreshold(long threshold) {
- this.threshold = threshold;
- }
-
- /**
- * Creates a constructor for a proxy class, if one doesn't already exist
- * @param idx - the index of the constructor
- * @param clazz - the interface that the proxy will implement
- * @return - returns a constructor used to create new instances
- * @throws NoSuchMethodException Constructor not found
- */
- protected Constructor<?> getConstructor(int idx, Class<?> clazz) throws NoSuchMethodException {
- if (constructors[idx]==null) {
- Class<?> proxyClass = Proxy.getProxyClass(SlowQueryReport.class.getClassLoader(), new Class[] {clazz});
- constructors[idx] = proxyClass.getConstructor(new Class[] { InvocationHandler.class });
- }
- return constructors[idx];
- }
-
- /**
- * Creates a statement interceptor to monitor query response times
- */
- @Override
- public Object createStatement(Object proxy, Method method, Object[] args, Object statement, long time) {
- try {
- Object result = null;
- String name = method.getName();
- String sql = null;
- Constructor<?> constructor = null;
- if (compare(CREATE_STATEMENT,name)) {
- //createStatement
- constructor = getConstructor(CREATE_STATEMENT_IDX,Statement.class);
- }else if (compare(PREPARE_STATEMENT,name)) {
- //prepareStatement
- sql = (String)args[0];
- constructor = getConstructor(PREPARE_STATEMENT_IDX,PreparedStatement.class);
- if (sql!=null) {
- prepareStatement(sql, time);
- }
- }else if (compare(PREPARE_CALL,name)) {
- //prepareCall
- sql = (String)args[0];
- constructor = getConstructor(PREPARE_CALL_IDX,CallableStatement.class);
- prepareCall(sql,time);
- }else {
- //do nothing, might be a future unsupported method
- //so we better bail out and let the system continue
- return statement;
- }
- result = constructor.newInstance(new Object[] { new StatementProxy(statement,sql) });
- return result;
- }catch (Exception x) {
- log.warn("Unable to create statement proxy for slow query report.",x);
- }
- return statement;
- }
-
-
- /**
- * Class to measure query execute time
- *
- */
- protected class StatementProxy implements InvocationHandler {
- protected boolean closed = false;
- protected Object delegate;
- protected final String query;
- public StatementProxy(Object parent, String query) {
- this.delegate = parent;
- this.query = query;
- }
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- //get the name of the method for comparison
- final String name = method.getName();
- //was close invoked?
- boolean close = compare(JdbcInterceptor.CLOSE_VAL,name);
- //allow close to be called multiple times
- if (close && closed) return null;
- //are we calling isClosed?
- if (compare(JdbcInterceptor.ISCLOSED_VAL,name)) return Boolean.valueOf(closed);
- //if we are calling anything else, bail out
- if (closed) throw new SQLException("Statement closed.");
- boolean process = false;
- //check to see if we are about to execute a query
- process = isExecute( method, process);
- //if we are executing, get the current time
- long start = (process)?System.currentTimeMillis():0;
- Object result = null;
- try {
- //execute the query
- result = method.invoke(delegate,args);
- }catch (Throwable t) {
- reportFailedQuery(query,args,name,start,t);
- if (t instanceof InvocationTargetException
- && t.getCause() != null) {
- throw t.getCause();
- } else {
- throw t;
- }
- }
- //measure the time
- long delta = (process)?(System.currentTimeMillis()-start):Long.MIN_VALUE;
- //see if we meet the requirements to measure
- if (delta>threshold) {
- try {
- //report the slow query
- reportSlowQuery(query, args, name, start, delta);
- }catch (Exception t) {
- if (log.isWarnEnabled()) log.warn("Unable to process slow query",t);
- }
- } else if (process) {
- reportQuery(query, args, name, start, delta);
- }
- //perform close cleanup
- if (close) {
- closed=true;
- delegate = null;
- }
- return result;
- }
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.lang.reflect.Method;
-import java.sql.SQLException;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.ConnectionPool;
-import org.apache.tomcat.jdbc.pool.DataSourceFactory;
-import org.apache.tomcat.jdbc.pool.JdbcInterceptor;
-import org.apache.tomcat.jdbc.pool.PoolConfiguration;
-import org.apache.tomcat.jdbc.pool.PooledConnection;
-
-/**
- * Interceptor that keep track of connection state to avoid roundtrips to the database.
- * The {@link org.apache.tomcat.jdbc.pool.ConnectionPool} is optimized to do as little work as possible.
- * The pool itself doesn't remember settings like {@link java.sql.Connection#setAutoCommit(boolean)},
- * {@link java.sql.Connection#setReadOnly(boolean)}, {@link java.sql.Connection#setCatalog(String)} or
- * {@link java.sql.Connection#setTransactionIsolation(int)}. It relies on the application to remember how and when
- * these settings have been applied.
- * In the cases where the application code doesn't know or want to keep track of the state, this interceptor helps cache the
- * state, and it also avoids roundtrips to the database asking for it.
- *
- */
-
-public class ConnectionState extends JdbcInterceptor {
- private static final Log log = LogFactory.getLog(ConnectionState.class);
-
- protected final String[] readState = {"getAutoCommit","getTransactionIsolation","isReadOnly","getCatalog"};
- protected final String[] writeState = {"setAutoCommit","setTransactionIsolation","setReadOnly","setCatalog"};
-
- protected Boolean autoCommit = null;
- protected Integer transactionIsolation = null;
- protected Boolean readOnly = null;
- protected String catalog = null;
-
-
- @Override
- public void reset(ConnectionPool parent, PooledConnection con) {
- if (parent==null || con==null) {
- //we are resetting, reset our defaults
- autoCommit = null;
- transactionIsolation = null;
- readOnly = null;
- catalog = null;
- return;
- }
- PoolConfiguration poolProperties = parent.getPoolProperties();
- if (poolProperties.getDefaultTransactionIsolation()!=DataSourceFactory.UNKNOWN_TRANSACTIONISOLATION) {
- try {
- if (transactionIsolation==null || transactionIsolation.intValue()!=poolProperties.getDefaultTransactionIsolation()) {
- con.getConnection().setTransactionIsolation(poolProperties.getDefaultTransactionIsolation());
- transactionIsolation = Integer.valueOf(poolProperties.getDefaultTransactionIsolation());
- }
- }catch (SQLException x) {
- transactionIsolation = null;
- log.error("Unable to reset transaction isolation state to connection.",x);
- }
- }
- if (poolProperties.getDefaultReadOnly()!=null) {
- try {
- if (readOnly==null || readOnly.booleanValue()!=poolProperties.getDefaultReadOnly().booleanValue()) {
- con.getConnection().setReadOnly(poolProperties.getDefaultReadOnly().booleanValue());
- readOnly = poolProperties.getDefaultReadOnly();
- }
- }catch (SQLException x) {
- readOnly = null;
- log.error("Unable to reset readonly state to connection.",x);
- }
- }
- if (poolProperties.getDefaultAutoCommit()!=null) {
- try {
- if (autoCommit==null || autoCommit.booleanValue()!=poolProperties.getDefaultAutoCommit().booleanValue()) {
- con.getConnection().setAutoCommit(poolProperties.getDefaultAutoCommit().booleanValue());
- autoCommit = poolProperties.getDefaultAutoCommit();
- }
- }catch (SQLException x) {
- autoCommit = null;
- log.error("Unable to reset autocommit state to connection.",x);
- }
- }
- if (poolProperties.getDefaultCatalog()!=null) {
- try {
- if (catalog==null || (!catalog.equals(poolProperties.getDefaultCatalog()))) {
- con.getConnection().setCatalog(poolProperties.getDefaultCatalog());
- catalog = poolProperties.getDefaultCatalog();
- }
- }catch (SQLException x) {
- catalog = null;
- log.error("Unable to reset default catalog state to connection.",x);
- }
- }
-
- }
-
-
- @Override
- public void disconnected(ConnectionPool parent, PooledConnection con, boolean finalizing) {
- //we are resetting, reset our defaults
- autoCommit = null;
- transactionIsolation = null;
- readOnly = null;
- catalog = null;
- super.disconnected(parent, con, finalizing);
- }
-
-
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- String name = method.getName();
- boolean read = false;
- int index = -1;
- for (int i=0; (!read) && i<readState.length; i++) {
- read = compare(name,readState[i]);
- if (read) index = i;
- }
- boolean write = false;
- for (int i=0; (!write) && (!read) && i<writeState.length; i++) {
- write = compare(name,writeState[i]);
- if (write) index = i;
- }
- Object result = null;
- if (read) {
- switch (index) {
- case 0:{result = autoCommit; break;}
- case 1:{result = transactionIsolation; break;}
- case 2:{result = readOnly; break;}
- case 3:{result = catalog; break;}
- default: // NOOP
- }
- //return cached result, if we have it
- if (result!=null) return result;
- }
-
- result = super.invoke(proxy, method, args);
- if (read || write) {
- switch (index) {
- case 0:{autoCommit = (Boolean) (read?result:args[0]); break;}
- case 1:{transactionIsolation = (Integer)(read?result:args[0]); break;}
- case 2:{readOnly = (Boolean)(read?result:args[0]); break;}
- case 3:{catalog = (String)(read?result:args[0]); break;}
- }
- }
- return result;
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.lang.reflect.Method;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.Map;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.PoolProperties.InterceptorProperty;
-
-public class QueryTimeoutInterceptor extends AbstractCreateStatementInterceptor {
- private static Log log = LogFactory.getLog(QueryTimeoutInterceptor.class);
- int timeout = 1;
-
- @Override
- public void setProperties(Map<String,InterceptorProperty> properties) {
- super.setProperties(properties);
- InterceptorProperty p = properties.get("queryTimeout");
- if (p!=null) timeout = p.getValueAsInt(timeout);
- }
-
- @Override
- public Object createStatement(Object proxy, Method method, Object[] args, Object statement, long time) {
- if (statement instanceof Statement && timeout > 0) {
- Statement s = (Statement)statement;
- try {
- s.setQueryTimeout(timeout);
- }catch (SQLException x) {
- log.warn("[QueryTimeoutInterceptor] Unable to set query timeout:"+x.getMessage(),x);
- }
- }
- return statement;
- }
-
- @Override
- public void closeInvoked() {
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.lang.reflect.Method;
-
-import org.apache.tomcat.jdbc.pool.JdbcInterceptor;
-import org.apache.tomcat.jdbc.pool.PooledConnection;
-import org.apache.tomcat.jdbc.pool.ProxyConnection;
-
-/**
- * Class that resets the abandoned timer on any activity on the
- * Connection or any successful query executions.
- * This interceptor is useful for when you have a {@link org.apache.tomcat.jdbc.pool.PoolConfiguration#setRemoveAbandonedTimeout(int)}
- * that is fairly low, and you want to reset the abandoned time each time any operation on the connection is performed
- * This is useful for batch processing programs that use connections for extensive amount of times.
- *
- */
-public class ResetAbandonedTimer extends AbstractQueryReport {
-
- public ResetAbandonedTimer() {
- }
-
- public boolean resetTimer() {
- boolean result = false;
- JdbcInterceptor interceptor = this.getNext();
- while (interceptor!=null && result==false) {
- if (interceptor instanceof ProxyConnection) {
- PooledConnection con = ((ProxyConnection)interceptor).getConnection();
- if (con!=null) {
- con.setTimestamp(System.currentTimeMillis());
- result = true;
- } else {
- break;
- }
- }
- interceptor = interceptor.getNext();
- }
- return result;
- }
-
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- Object result = super.invoke(proxy, method, args);
- resetTimer();
- return result;
- }
-
- @Override
- protected void prepareCall(String query, long time) {
- resetTimer();
- }
-
- @Override
- protected void prepareStatement(String sql, long time) {
- resetTimer();
-
- }
-
- @Override
- public void closeInvoked() {
- resetTimer();
- }
-
- @Override
- protected String reportQuery(String query, Object[] args, String name,long start, long delta) {
- resetTimer();
- return super.reportQuery(query, args, name, start, delta);
- }
-
- @Override
- protected String reportSlowQuery(String query, Object[] args, String name,long start, long delta) {
- resetTimer();
- return super.reportSlowQuery(query, args, name, start, delta);
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Locale;
-import java.util.Map;
-import java.util.TimeZone;
-import java.util.concurrent.ConcurrentHashMap;
-
-import javax.management.openmbean.CompositeDataSupport;
-import javax.management.openmbean.CompositeType;
-import javax.management.openmbean.OpenDataException;
-import javax.management.openmbean.OpenType;
-import javax.management.openmbean.SimpleType;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.ConnectionPool;
-import org.apache.tomcat.jdbc.pool.PoolProperties.InterceptorProperty;
-import org.apache.tomcat.jdbc.pool.PooledConnection;
-
-/**
- * Slow query report interceptor. Tracks timing of query executions.
- * @version 1.0
- */
-public class SlowQueryReport extends AbstractQueryReport {
- //logger
- private static final Log log = LogFactory.getLog(SlowQueryReport.class);
-
- /**
- * we will be keeping track of query stats on a per pool basis
- */
- protected static final ConcurrentHashMap<String,ConcurrentHashMap<String,QueryStats>> perPoolStats =
- new ConcurrentHashMap<>();
- /**
- * the queries that are used for this interceptor.
- */
- protected volatile ConcurrentHashMap<String,QueryStats> queries = null;
- /**
- * Maximum number of queries we will be storing
- */
- protected int maxQueries= 1000; //don't store more than this amount of queries
-
- /**
- * Flag to enable disable logging of slow queries
- */
- protected boolean logSlow = true;
-
- /**
- * Flag to enable disable logging of failed queries
- */
- protected boolean logFailed = false;
-
- /**
- * Sort QueryStats by last invocation time
- */
- protected final Comparator<QueryStats> queryStatsComparator = new QueryStatsComparator();
-
- /**
- * Returns the query stats for a given pool
- * @param poolname - the name of the pool we want to retrieve stats for
- * @return a hash map containing statistics for 0 to maxQueries
- */
- public static ConcurrentHashMap<String,QueryStats> getPoolStats(String poolname) {
- return perPoolStats.get(poolname);
- }
-
- /**
- * Creates a slow query report interceptor
- */
- public SlowQueryReport() {
- super();
- }
-
- public void setMaxQueries(int maxQueries) {
- this.maxQueries = maxQueries;
- }
-
-
- @Override
- protected String reportFailedQuery(String query, Object[] args, String name, long start, Throwable t) {
- String sql = super.reportFailedQuery(query, args, name, start, t);
- if (this.maxQueries > 0 ) {
- long now = System.currentTimeMillis();
- long delta = now - start;
- QueryStats qs = this.getQueryStats(sql);
- if (qs != null) {
- qs.failure(delta, now);
- if (isLogFailed() && log.isWarnEnabled()) {
- log.warn("Failed Query Report SQL="+sql+"; time="+delta+" ms;");
- }
- }
- }
- return sql;
- }
-
- @Override
- protected String reportQuery(String query, Object[] args, final String name, long start, long delta) {
- String sql = super.reportQuery(query, args, name, start, delta);
- if (this.maxQueries > 0 ) {
- QueryStats qs = this.getQueryStats(sql);
- if (qs != null) qs.add(delta, start);
- }
- return sql;
- }
-
- @Override
- protected String reportSlowQuery(String query, Object[] args, String name, long start, long delta) {
- String sql = super.reportSlowQuery(query, args, name, start, delta);
- if (this.maxQueries > 0 ) {
- QueryStats qs = this.getQueryStats(sql);
- if (qs != null) {
- qs.add(delta, start);
- if (isLogSlow() && log.isWarnEnabled()) {
- log.warn("Slow Query Report SQL="+sql+"; time="+delta+" ms;");
- }
- }
- }
- return sql;
- }
-
- /**
- * invoked when the connection receives the close request
- * Not used for now.
- */
- @Override
- public void closeInvoked() {
- // NOOP
- }
-
- @Override
- public void prepareStatement(String sql, long time) {
- if (this.maxQueries > 0 ) {
- QueryStats qs = getQueryStats(sql);
- if (qs != null) qs.prepare(time);
- }
- }
-
- @Override
- public void prepareCall(String sql, long time) {
- if (this.maxQueries > 0 ) {
- QueryStats qs = getQueryStats(sql);
- if (qs != null) qs.prepare(time);
- }
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void poolStarted(ConnectionPool pool) {
- super.poolStarted(pool);
- //see if we already created a map for this pool
- queries = SlowQueryReport.perPoolStats.get(pool.getName());
- if (queries==null) {
- //create the map to hold our stats
- //however TODO we need to improve the eviction
- //selection
- queries = new ConcurrentHashMap<>();
- if (perPoolStats.putIfAbsent(pool.getName(), queries)!=null) {
- //there already was one
- queries = SlowQueryReport.perPoolStats.get(pool.getName());
- }
- }
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void poolClosed(ConnectionPool pool) {
- perPoolStats.remove(pool.getName());
- super.poolClosed(pool);
- }
-
- protected QueryStats getQueryStats(String sql) {
- if (sql==null) sql = "";
- ConcurrentHashMap<String,QueryStats> queries = SlowQueryReport.this.queries;
- if (queries==null) {
- if (log.isWarnEnabled()) log.warn("Connection has already been closed or abandoned");
- return null;
- }
- QueryStats qs = queries.get(sql);
- if (qs == null) {
- qs = new QueryStats(sql);
- if (queries.putIfAbsent(sql,qs)!=null) {
- qs = queries.get(sql);
- } else {
- //we added a new element, see if we need to remove the oldest
- if (queries.size() > maxQueries) {
- removeOldest(queries);
- }
- }
- }
- return qs;
- }
-
- /**
- * Sort QueryStats by last invocation time
- * @param queries The queries map
- */
- protected void removeOldest(ConcurrentHashMap<String,QueryStats> queries) {
- ArrayList<QueryStats> list = new ArrayList<>(queries.values());
- Collections.sort(list, queryStatsComparator);
- int removeIndex = 0;
- while (queries.size() > maxQueries) {
- String sql = list.get(removeIndex).getQuery();
- queries.remove(sql);
- if (log.isDebugEnabled()) log.debug("Removing slow query, capacity reached:"+sql);
- removeIndex++;
- }
- }
-
-
- @Override
- public void reset(ConnectionPool parent, PooledConnection con) {
- super.reset(parent, con);
- if (parent!=null)
- queries = SlowQueryReport.perPoolStats.get(parent.getName());
- else
- queries = null;
- }
-
-
- public boolean isLogSlow() {
- return logSlow;
- }
-
- public void setLogSlow(boolean logSlow) {
- this.logSlow = logSlow;
- }
-
- public boolean isLogFailed() {
- return logFailed;
- }
-
- public void setLogFailed(boolean logFailed) {
- this.logFailed = logFailed;
- }
-
- @Override
- public void setProperties(Map<String, InterceptorProperty> properties) {
- super.setProperties(properties);
- final String threshold = "threshold";
- final String maxqueries= "maxQueries";
- final String logslow = "logSlow";
- final String logfailed = "logFailed";
- InterceptorProperty p1 = properties.get(threshold);
- InterceptorProperty p2 = properties.get(maxqueries);
- InterceptorProperty p3 = properties.get(logslow);
- InterceptorProperty p4 = properties.get(logfailed);
- if (p1!=null) {
- setThreshold(Long.parseLong(p1.getValue()));
- }
- if (p2!=null) {
- setMaxQueries(Integer.parseInt(p2.getValue()));
- }
- if (p3!=null) {
- setLogSlow(Boolean.parseBoolean(p3.getValue()));
- }
- if (p4!=null) {
- setLogFailed(Boolean.parseBoolean(p4.getValue()));
- }
- }
-
-
- public static class QueryStats {
- static final String[] FIELD_NAMES = new String[] {
- "query",
- "nrOfInvocations",
- "maxInvocationTime",
- "maxInvocationDate",
- "minInvocationTime",
- "minInvocationDate",
- "totalInvocationTime",
- "failures",
- "prepareCount",
- "prepareTime",
- "lastInvocation"
- };
-
- static final String[] FIELD_DESCRIPTIONS = new String[] {
- "The SQL query",
- "The number of query invocations, a call to executeXXX",
- "The longest time for this query in milliseconds",
- "The time and date for when the longest query took place",
- "The shortest time for this query in milliseconds",
- "The time and date for when the shortest query took place",
- "The total amount of milliseconds spent executing this query",
- "The number of failures for this query",
- "The number of times this query was prepared (prepareStatement/prepareCall)",
- "The total number of milliseconds spent preparing this query",
- "The date and time of the last invocation"
- };
-
- static final OpenType<?>[] FIELD_TYPES = new OpenType[] {
- SimpleType.STRING,
- SimpleType.INTEGER,
- SimpleType.LONG,
- SimpleType.LONG,
- SimpleType.LONG,
- SimpleType.LONG,
- SimpleType.LONG,
- SimpleType.LONG,
- SimpleType.INTEGER,
- SimpleType.LONG,
- SimpleType.LONG
- };
-
- private final String query;
- private volatile int nrOfInvocations;
- private volatile long maxInvocationTime = Long.MIN_VALUE;
- private volatile long maxInvocationDate;
- private volatile long minInvocationTime = Long.MAX_VALUE;
- private volatile long minInvocationDate;
- private volatile long totalInvocationTime;
- private volatile long failures;
- private volatile int prepareCount;
- private volatile long prepareTime;
- private volatile long lastInvocation = 0;
-
- public static String[] getFieldNames() {
- return FIELD_NAMES;
- }
-
- public static String[] getFieldDescriptions() {
- return FIELD_DESCRIPTIONS;
- }
-
- public static OpenType<?>[] getFieldTypes() {
- return FIELD_TYPES;
- }
-
- @Override
- public String toString() {
- SimpleDateFormat sdf =
- new SimpleDateFormat("d MMM yyyy HH:mm:ss z", Locale.US);
- sdf.setTimeZone(TimeZone.getTimeZone("GMT"));
- StringBuilder buf = new StringBuilder("QueryStats[query:");
- buf.append(query);
- buf.append(", nrOfInvocations:");
- buf.append(nrOfInvocations);
- buf.append(", maxInvocationTime:");
- buf.append(maxInvocationTime);
- buf.append(", maxInvocationDate:");
- buf.append(sdf.format(new java.util.Date(maxInvocationDate)));
- buf.append(", minInvocationTime:");
- buf.append(minInvocationTime);
- buf.append(", minInvocationDate:");
- buf.append(sdf.format(new java.util.Date(minInvocationDate)));
- buf.append(", totalInvocationTime:");
- buf.append(totalInvocationTime);
- buf.append(", averageInvocationTime:");
- buf.append((float)totalInvocationTime / (float)nrOfInvocations);
- buf.append(", failures:");
- buf.append(failures);
- buf.append(", prepareCount:");
- buf.append(prepareCount);
- buf.append(", prepareTime:");
- buf.append(prepareTime);
- buf.append("]");
- return buf.toString();
- }
-
- public CompositeDataSupport getCompositeData(final CompositeType type) throws OpenDataException{
- Object[] values = new Object[] {
- query,
- Integer.valueOf(nrOfInvocations),
- Long.valueOf(maxInvocationTime),
- Long.valueOf(maxInvocationDate),
- Long.valueOf(minInvocationTime),
- Long.valueOf(minInvocationDate),
- Long.valueOf(totalInvocationTime),
- Long.valueOf(failures),
- Integer.valueOf(prepareCount),
- Long.valueOf(prepareTime),
- Long.valueOf(lastInvocation)
- };
- return new CompositeDataSupport(type,FIELD_NAMES,values);
- }
-
- public QueryStats(String query) {
- this.query = query;
- }
-
- public void prepare(long invocationTime) {
- prepareCount++;
- prepareTime+=invocationTime;
-
- }
-
- public void add(long invocationTime, long now) {
- //not thread safe, but don't sacrifice performance for this kind of stuff
- maxInvocationTime = Math.max(invocationTime, maxInvocationTime);
- if (maxInvocationTime == invocationTime) {
- maxInvocationDate = now;
- }
- minInvocationTime = Math.min(invocationTime, minInvocationTime);
- if (minInvocationTime==invocationTime) {
- minInvocationDate = now;
- }
- nrOfInvocations++;
- totalInvocationTime+=invocationTime;
- lastInvocation = now;
- }
-
- public void failure(long invocationTime, long now) {
- add(invocationTime,now);
- failures++;
-
- }
-
- public String getQuery() {
- return query;
- }
-
- public int getNrOfInvocations() {
- return nrOfInvocations;
- }
-
- public long getMaxInvocationTime() {
- return maxInvocationTime;
- }
-
- public long getMaxInvocationDate() {
- return maxInvocationDate;
- }
-
- public long getMinInvocationTime() {
- return minInvocationTime;
- }
-
- public long getMinInvocationDate() {
- return minInvocationDate;
- }
-
- public long getTotalInvocationTime() {
- return totalInvocationTime;
- }
-
- @Override
- public int hashCode() {
- return query.hashCode();
- }
-
- @Override
- public boolean equals(Object other) {
- if (other instanceof QueryStats) {
- QueryStats qs = (QueryStats)other;
- return qs.query.equals(this.query);
- }
- return false;
- }
-
- public boolean isOlderThan(QueryStats other) {
- return this.lastInvocation < other.lastInvocation;
- }
- }
-
- /** Compare QueryStats by their lastInvocation value. QueryStats that
- * have never been updated, have a lastInvocation value of {@code 0}
- * which should be handled as the newest possible invocation.
- */
- private static class QueryStatsComparator implements Comparator<QueryStats> {
-
- @Override
- public int compare(QueryStats stats1, QueryStats stats2) {
- return Long.compare(handleZero(stats1.lastInvocation),
- handleZero(stats2.lastInvocation));
- }
-
- private static long handleZero(long value) {
- return value == 0 ? Long.MAX_VALUE : value;
- }
-
- }
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.lang.management.ManagementFactory;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicLong;
-
-import javax.management.InstanceAlreadyExistsException;
-import javax.management.InstanceNotFoundException;
-import javax.management.ListenerNotFoundException;
-import javax.management.MBeanException;
-import javax.management.MBeanNotificationInfo;
-import javax.management.MBeanRegistrationException;
-import javax.management.MalformedObjectNameException;
-import javax.management.NotCompliantMBeanException;
-import javax.management.Notification;
-import javax.management.NotificationBroadcasterSupport;
-import javax.management.NotificationEmitter;
-import javax.management.NotificationFilter;
-import javax.management.NotificationListener;
-import javax.management.ObjectName;
-import javax.management.RuntimeOperationsException;
-import javax.management.openmbean.CompositeData;
-import javax.management.openmbean.CompositeDataSupport;
-import javax.management.openmbean.CompositeType;
-import javax.management.openmbean.OpenDataException;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.ConnectionPool;
-import org.apache.tomcat.jdbc.pool.PoolProperties.InterceptorProperty;
-import org.apache.tomcat.jdbc.pool.PooledConnection;
-/**
- * Publishes data to JMX and provides notifications
- * when failures happen.
- *
- */
-public class SlowQueryReportJmx extends SlowQueryReport implements NotificationEmitter, SlowQueryReportJmxMBean{
- public static final String SLOW_QUERY_NOTIFICATION = "SLOW QUERY";
- public static final String FAILED_QUERY_NOTIFICATION = "FAILED QUERY";
-
- public static final String objectNameAttribute = "objectName";
-
- protected static volatile CompositeType SLOW_QUERY_TYPE;
-
- private static final Log log = LogFactory.getLog(SlowQueryReportJmx.class);
-
-
- protected static final ConcurrentHashMap<String,SlowQueryReportJmxMBean> mbeans =
- new ConcurrentHashMap<>();
-
-
- //==============================JMX STUFF========================
- protected volatile NotificationBroadcasterSupport notifier = new NotificationBroadcasterSupport();
-
- @Override
- public void addNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) throws IllegalArgumentException {
- notifier.addNotificationListener(listener, filter, handback);
- }
-
-
- @Override
- public MBeanNotificationInfo[] getNotificationInfo() {
- return notifier.getNotificationInfo();
- }
-
- @Override
- public void removeNotificationListener(NotificationListener listener) throws ListenerNotFoundException {
- notifier.removeNotificationListener(listener);
-
- }
-
- @Override
- public void removeNotificationListener(NotificationListener listener, NotificationFilter filter, Object handback) throws ListenerNotFoundException {
- notifier.removeNotificationListener(listener, filter, handback);
-
- }
-
-
- //==============================JMX STUFF========================
-
- protected String poolName = null;
-
- protected static final AtomicLong notifySequence = new AtomicLong(0);
-
- protected boolean notifyPool = true;
-
- protected ConnectionPool pool = null;
-
- protected static CompositeType getCompositeType() {
- if (SLOW_QUERY_TYPE==null) {
- try {
- SLOW_QUERY_TYPE = new CompositeType(
- SlowQueryReportJmx.class.getName(),
- "Composite data type for query statistics",
- QueryStats.getFieldNames(),
- QueryStats.getFieldDescriptions(),
- QueryStats.getFieldTypes());
- }catch (OpenDataException x) {
- log.warn("Unable to initialize composite data type for JMX stats and notifications.",x);
- }
- }
- return SLOW_QUERY_TYPE;
- }
-
- @Override
- public void reset(ConnectionPool parent, PooledConnection con) {
- super.reset(parent, con);
- if (parent!=null) {
- poolName = parent.getName();
- pool = parent;
- registerJmx();
- }
- }
-
-
- @Override
- public void poolClosed(ConnectionPool pool) {
- this.poolName = pool.getName();
- deregisterJmx();
- super.poolClosed(pool);
- }
-
- @Override
- public void poolStarted(ConnectionPool pool) {
- this.pool = pool;
- super.poolStarted(pool);
- this.poolName = pool.getName();
- }
-
- @Override
- protected String reportFailedQuery(String query, Object[] args, String name, long start, Throwable t) {
- query = super.reportFailedQuery(query, args, name, start, t);
- if (isLogFailed()) notifyJmx(query,FAILED_QUERY_NOTIFICATION);
- return query;
- }
-
- protected void notifyJmx(String query, String type) {
- try {
- long sequence = notifySequence.incrementAndGet();
-
- if (isNotifyPool()) {
- if (this.pool!=null && this.pool.getJmxPool()!=null) {
- this.pool.getJmxPool().notify(type, query);
- }
- } else {
- if (notifier!=null) {
- Notification notification =
- new Notification(type,
- this,
- sequence,
- System.currentTimeMillis(),
- query);
-
- notifier.sendNotification(notification);
- }
- }
- } catch (RuntimeOperationsException e) {
- if (log.isDebugEnabled()) {
- log.debug("Unable to send failed query notification.",e);
- }
- }
- }
-
- @Override
- protected String reportSlowQuery(String query, Object[] args, String name, long start, long delta) {
- query = super.reportSlowQuery(query, args, name, start, delta);
- if (isLogSlow()) notifyJmx(query,SLOW_QUERY_NOTIFICATION);
- return query;
- }
-
- /**
- * JMX operation - return the names of all the pools
- * @return - all the names of pools that we have stored data for
- */
- public String[] getPoolNames() {
- Set<String> keys = perPoolStats.keySet();
- return keys.toArray(new String[0]);
- }
-
- /**
- * JMX operation - return the name of the pool
- * @return the name of the pool, unique within the JVM
- */
- public String getPoolName() {
- return poolName;
- }
-
-
- public boolean isNotifyPool() {
- return notifyPool;
- }
-
- public void setNotifyPool(boolean notifyPool) {
- this.notifyPool = notifyPool;
- }
-
- /**
- * JMX operation - remove all stats for this connection pool
- */
- public void resetStats() {
- ConcurrentHashMap<String,QueryStats> queries = perPoolStats.get(poolName);
- if (queries!=null) {
- Iterator<String> it = queries.keySet().iterator();
- while (it.hasNext()) it.remove();
- }
- }
-
- /**
- * JMX operation - returns all the queries we have collected.
- * @return - the slow query report as composite data.
- */
- @Override
- public CompositeData[] getSlowQueriesCD() throws OpenDataException {
- CompositeDataSupport[] result = null;
- ConcurrentHashMap<String,QueryStats> queries = perPoolStats.get(poolName);
- if (queries!=null) {
- Set<Map.Entry<String,QueryStats>> stats = queries.entrySet();
- if (stats!=null) {
- result = new CompositeDataSupport[stats.size()];
- Iterator<Map.Entry<String,QueryStats>> it = stats.iterator();
- int pos = 0;
- while (it.hasNext()) {
- Map.Entry<String,QueryStats> entry = it.next();
- QueryStats qs = entry.getValue();
- result[pos++] = qs.getCompositeData(getCompositeType());
- }
- }
- }
- return result;
- }
-
- protected void deregisterJmx() {
- try {
- if (mbeans.remove(poolName)!=null) {
- ObjectName oname = getObjectName(getClass(),poolName);
- ManagementFactory.getPlatformMBeanServer().unregisterMBean(oname);
- }
- } catch (MBeanRegistrationException e) {
- log.debug("Jmx deregistration failed.",e);
- } catch (InstanceNotFoundException e) {
- log.debug("Jmx deregistration failed.",e);
- } catch (MalformedObjectNameException e) {
- log.warn("Jmx deregistration failed.",e);
- } catch (RuntimeOperationsException e) {
- log.warn("Jmx deregistration failed.",e);
- }
-
- }
-
-
- public ObjectName getObjectName(Class<?> clazz, String poolName) throws MalformedObjectNameException {
- ObjectName oname;
- Map<String,InterceptorProperty> properties = getProperties();
- if (properties != null && properties.containsKey(objectNameAttribute)) {
- oname = new ObjectName(properties.get(objectNameAttribute).getValue());
- } else {
- oname = new ObjectName(ConnectionPool.POOL_JMX_TYPE_PREFIX+clazz.getName()+",name=" + poolName);
- }
- return oname;
- }
-
- protected void registerJmx() {
- try {
- //only if we notify the pool itself
- if (isNotifyPool()) {
-
- } else if (getCompositeType()!=null) {
- ObjectName oname = getObjectName(getClass(),poolName);
- if (mbeans.putIfAbsent(poolName, this)==null) {
- ManagementFactory.getPlatformMBeanServer().registerMBean(this, oname);
- }
- } else {
- log.warn(SlowQueryReport.class.getName()+ "- No JMX support, composite type was not found.");
- }
- } catch (MalformedObjectNameException e) {
- log.error("Jmx registration failed, no JMX data will be exposed for the query stats.",e);
- } catch (RuntimeOperationsException e) {
- log.error("Jmx registration failed, no JMX data will be exposed for the query stats.",e);
- } catch (MBeanException e) {
- log.error("Jmx registration failed, no JMX data will be exposed for the query stats.",e);
- } catch (InstanceAlreadyExistsException e) {
- log.error("Jmx registration failed, no JMX data will be exposed for the query stats.",e);
- } catch (NotCompliantMBeanException e) {
- log.error("Jmx registration failed, no JMX data will be exposed for the query stats.",e);
- }
- }
-
- @Override
- public void setProperties(Map<String, InterceptorProperty> properties) {
- super.setProperties(properties);
- final String threshold = "notifyPool";
- InterceptorProperty p1 = properties.get(threshold);
- if (p1!=null) {
- this.setNotifyPool(Boolean.parseBoolean(p1.getValue()));
- }
- }
-
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import javax.management.openmbean.CompositeData;
-import javax.management.openmbean.OpenDataException;
-
-public interface SlowQueryReportJmxMBean {
- public CompositeData[] getSlowQueriesCD() throws OpenDataException;
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.sql.ResultSet;
-import java.sql.Statement;
-import java.util.Arrays;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.apache.tomcat.jdbc.pool.ConnectionPool;
-import org.apache.tomcat.jdbc.pool.PoolProperties.InterceptorProperty;
-import org.apache.tomcat.jdbc.pool.PooledConnection;
-
-/**
- * Interceptor that caches {@code PreparedStatement} and/or
- * {@code CallableStatement} instances on a connection.
- */
-public class StatementCache extends StatementDecoratorInterceptor {
- protected static final String[] ALL_TYPES = new String[] {PREPARE_STATEMENT,PREPARE_CALL};
- protected static final String[] CALLABLE_TYPE = new String[] {PREPARE_CALL};
- protected static final String[] PREPARED_TYPE = new String[] {PREPARE_STATEMENT};
- protected static final String[] NO_TYPE = new String[] {};
-
- protected static final String STATEMENT_CACHE_ATTR = StatementCache.class.getName() + ".cache";
-
- /*begin properties for the statement cache*/
- private boolean cachePrepared = true;
- private boolean cacheCallable = false;
- private int maxCacheSize = 50;
- private PooledConnection pcon;
- private String[] types;
-
-
- public boolean isCachePrepared() {
- return cachePrepared;
- }
-
- public boolean isCacheCallable() {
- return cacheCallable;
- }
-
- public int getMaxCacheSize() {
- return maxCacheSize;
- }
-
- public String[] getTypes() {
- return types;
- }
-
- public AtomicInteger getCacheSize() {
- return cacheSize;
- }
-
- @Override
- public void setProperties(Map<String, InterceptorProperty> properties) {
- super.setProperties(properties);
- InterceptorProperty p = properties.get("prepared");
- if (p!=null) cachePrepared = p.getValueAsBoolean(cachePrepared);
- p = properties.get("callable");
- if (p!=null) cacheCallable = p.getValueAsBoolean(cacheCallable);
- p = properties.get("max");
- if (p!=null) maxCacheSize = p.getValueAsInt(maxCacheSize);
- if (cachePrepared && cacheCallable) {
- this.types = ALL_TYPES;
- } else if (cachePrepared) {
- this.types = PREPARED_TYPE;
- } else if (cacheCallable) {
- this.types = CALLABLE_TYPE;
- } else {
- this.types = NO_TYPE;
- }
-
- }
- /*end properties for the statement cache*/
-
- /*begin the cache size*/
- private static ConcurrentHashMap<ConnectionPool,AtomicInteger> cacheSizeMap =
- new ConcurrentHashMap<>();
-
- private AtomicInteger cacheSize;
-
- @Override
- public void poolStarted(ConnectionPool pool) {
- cacheSizeMap.putIfAbsent(pool, new AtomicInteger(0));
- super.poolStarted(pool);
- }
-
- @Override
- public void poolClosed(ConnectionPool pool) {
- cacheSizeMap.remove(pool);
- super.poolClosed(pool);
- }
- /*end the cache size*/
-
- /*begin the actual statement cache*/
- @Override
- public void reset(ConnectionPool parent, PooledConnection con) {
- super.reset(parent, con);
- if (parent==null) {
- cacheSize = null;
- this.pcon = null;
- } else {
- cacheSize = cacheSizeMap.get(parent);
- this.pcon = con;
- if (!pcon.getAttributes().containsKey(STATEMENT_CACHE_ATTR)) {
- ConcurrentHashMap<CacheKey,CachedStatement> cache =
- new ConcurrentHashMap<>();
- pcon.getAttributes().put(STATEMENT_CACHE_ATTR,cache);
- }
- }
- }
-
- @Override
- public void disconnected(ConnectionPool parent, PooledConnection con, boolean finalizing) {
- @SuppressWarnings("unchecked")
- ConcurrentHashMap<CacheKey,CachedStatement> statements =
- (ConcurrentHashMap<CacheKey,CachedStatement>)con.getAttributes().get(STATEMENT_CACHE_ATTR);
-
- if (statements!=null) {
- for (Map.Entry<CacheKey, CachedStatement> p : statements.entrySet()) {
- closeStatement(p.getValue());
- }
- statements.clear();
- }
-
- super.disconnected(parent, con, finalizing);
- }
-
- public void closeStatement(CachedStatement st) {
- if (st==null) return;
- st.forceClose();
- }
-
- @Override
- protected Object createDecorator(Object proxy, Method method, Object[] args,
- Object statement, Constructor<?> constructor, String sql)
- throws InstantiationException, IllegalAccessException, InvocationTargetException {
- boolean process = process(this.types, method, false);
- if (process) {
- Object result = null;
- CachedStatement statementProxy = new CachedStatement((Statement)statement,sql);
- result = constructor.newInstance(new Object[] { statementProxy });
- statementProxy.setActualProxy(result);
- statementProxy.setConnection(proxy);
- statementProxy.setConstructor(constructor);
- statementProxy.setCacheKey(createCacheKey(method, args));
- return result;
- } else {
- return super.createDecorator(proxy, method, args, statement, constructor, sql);
- }
- }
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- boolean process = process(this.types, method, false);
- if (process && args.length>0 && args[0] instanceof String) {
- CachedStatement statement = isCached(method, args);
- if (statement!=null) {
- //remove it from the cache since it is used
- removeStatement(statement);
- return statement.getActualProxy();
- } else {
- return super.invoke(proxy, method, args);
- }
- } else {
- return super.invoke(proxy,method,args);
- }
- }
-
- public CachedStatement isCached(Method method, Object[] args) {
- @SuppressWarnings("unchecked")
- ConcurrentHashMap<CacheKey,CachedStatement> cache =
- (ConcurrentHashMap<CacheKey,CachedStatement>)pcon.getAttributes().get(STATEMENT_CACHE_ATTR);
- return cache.get(createCacheKey(method, args));
- }
-
- public boolean cacheStatement(CachedStatement proxy) {
- @SuppressWarnings("unchecked")
- ConcurrentHashMap<CacheKey,CachedStatement> cache =
- (ConcurrentHashMap<CacheKey,CachedStatement>)pcon.getAttributes().get(STATEMENT_CACHE_ATTR);
- if (proxy.getCacheKey()==null) {
- return false;
- } else if (cache.containsKey(proxy.getCacheKey())) {
- return false;
- } else if (cacheSize.get()>=maxCacheSize) {
- return false;
- } else if (cacheSize.incrementAndGet()>maxCacheSize) {
- cacheSize.decrementAndGet();
- return false;
- } else {
- //cache the statement
- cache.put(proxy.getCacheKey(), proxy);
- return true;
- }
- }
-
- public boolean removeStatement(CachedStatement proxy) {
- @SuppressWarnings("unchecked")
- ConcurrentHashMap<CacheKey,CachedStatement> cache =
- (ConcurrentHashMap<CacheKey,CachedStatement>)pcon.getAttributes().get(STATEMENT_CACHE_ATTR);
- if (cache.remove(proxy.getCacheKey()) != null) {
- cacheSize.decrementAndGet();
- return true;
- } else {
- return false;
- }
- }
- /*end the actual statement cache*/
-
-
- protected class CachedStatement extends StatementDecoratorInterceptor.StatementProxy<Statement> {
- boolean cached = false;
- CacheKey key;
- public CachedStatement(Statement parent, String sql) {
- super(parent, sql);
- }
-
- @Override
- public void closeInvoked() {
- //should we cache it
- boolean shouldClose = true;
- if (cacheSize.get() < maxCacheSize) {
- //cache a proxy so that we don't reuse the facade
- CachedStatement proxy = new CachedStatement(getDelegate(),getSql());
- proxy.setCacheKey(getCacheKey());
- try {
- // clear Resultset
- ResultSet result = getDelegate().getResultSet();
- if (result != null && !result.isClosed()) {
- result.close();
- }
- //create a new facade
- Object actualProxy = getConstructor().newInstance(new Object[] { proxy });
- proxy.setActualProxy(actualProxy);
- proxy.setConnection(getConnection());
- proxy.setConstructor(getConstructor());
- if (cacheStatement(proxy)) {
- proxy.cached = true;
- shouldClose = false;
- }
- } catch (Exception x) {
- removeStatement(proxy);
- }
- }
- if (shouldClose) {
- super.closeInvoked();
- }
- closed = true;
- delegate = null;
-
- }
-
- public void forceClose() {
- removeStatement(this);
- super.closeInvoked();
- }
-
- public CacheKey getCacheKey() {
- return key;
- }
-
- public void setCacheKey(CacheKey cacheKey) {
- key = cacheKey;
- }
-
- }
-
- protected CacheKey createCacheKey(Method method, Object[] args) {
- return createCacheKey(method.getName(), args);
- }
-
- protected CacheKey createCacheKey(String methodName, Object[] args) {
- CacheKey key = null;
- if (compare(PREPARE_STATEMENT, methodName)) {
- key = new CacheKey(PREPARE_STATEMENT, args);
- } else if (compare(PREPARE_CALL, methodName)) {
- key = new CacheKey(PREPARE_CALL, args);
- }
- return key;
- }
-
-
- private static final class CacheKey {
- private final String stmtType;
- private final Object[] args;
- private CacheKey(String type, Object[] methodArgs) {
- stmtType = type;
- args = methodArgs;
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + Arrays.hashCode(args);
- result = prime * result
- + ((stmtType == null) ? 0 : stmtType.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- CacheKey other = (CacheKey) obj;
- if (!Arrays.equals(args, other.args))
- return false;
- if (stmtType == null) {
- if (other.stmtType != null)
- return false;
- } else if (!stmtType.equals(other.stmtType))
- return false;
- return true;
- }
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.sql.CallableStatement;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-
-/**
- * Implementation of <b>JdbcInterceptor</b> that proxies resultSets and statements.
- * @author Guillermo Fernandes
- */
-public class StatementDecoratorInterceptor extends AbstractCreateStatementInterceptor {
-
- private static final Log logger = LogFactory.getLog(StatementDecoratorInterceptor.class);
-
- protected static final String EXECUTE_QUERY = "executeQuery";
- protected static final String GET_GENERATED_KEYS = "getGeneratedKeys";
- protected static final String GET_RESULTSET = "getResultSet";
-
- protected static final String[] RESULTSET_TYPES = {EXECUTE_QUERY, GET_GENERATED_KEYS, GET_RESULTSET};
-
- /**
- * the constructors that are used to create statement proxies
- */
- protected static final Constructor<?>[] constructors = new Constructor[AbstractCreateStatementInterceptor.STATEMENT_TYPE_COUNT];
-
- /**
- * the constructor to create the resultSet proxies
- */
- protected static Constructor<?> resultSetConstructor = null;
-
- @Override
- public void closeInvoked() {
- // nothing to do
- }
-
- /**
- * Creates a constructor for a proxy class, if one doesn't already exist
- *
- * @param idx
- * - the index of the constructor
- * @param clazz
- * - the interface that the proxy will implement
- * @return - returns a constructor used to create new instances
- * @throws NoSuchMethodException Constructor not found
- */
- protected Constructor<?> getConstructor(int idx, Class<?> clazz) throws NoSuchMethodException {
- if (constructors[idx] == null) {
- Class<?> proxyClass = Proxy.getProxyClass(StatementDecoratorInterceptor.class.getClassLoader(),
- new Class[] { clazz });
- constructors[idx] = proxyClass.getConstructor(new Class[] { InvocationHandler.class });
- }
- return constructors[idx];
- }
-
- protected Constructor<?> getResultSetConstructor() throws NoSuchMethodException {
- if (resultSetConstructor == null) {
- Class<?> proxyClass = Proxy.getProxyClass(StatementDecoratorInterceptor.class.getClassLoader(),
- new Class[] { ResultSet.class });
- resultSetConstructor = proxyClass.getConstructor(new Class[] { InvocationHandler.class });
- }
- return resultSetConstructor;
- }
-
- /**
- * Creates a statement interceptor to monitor query response times
- */
- @Override
- public Object createStatement(Object proxy, Method method, Object[] args, Object statement, long time) {
- try {
- String name = method.getName();
- Constructor<?> constructor = null;
- String sql = null;
- if (compare(CREATE_STATEMENT, name)) {
- // createStatement
- constructor = getConstructor(CREATE_STATEMENT_IDX, Statement.class);
- } else if (compare(PREPARE_STATEMENT, name)) {
- // prepareStatement
- constructor = getConstructor(PREPARE_STATEMENT_IDX, PreparedStatement.class);
- sql = (String)args[0];
- } else if (compare(PREPARE_CALL, name)) {
- // prepareCall
- constructor = getConstructor(PREPARE_CALL_IDX, CallableStatement.class);
- sql = (String)args[0];
- } else {
- // do nothing, might be a future unsupported method
- // so we better bail out and let the system continue
- return statement;
- }
- return createDecorator(proxy, method, args, statement, constructor, sql);
- } catch (Exception x) {
- if (x instanceof InvocationTargetException) {
- Throwable cause = x.getCause();
- if (cause instanceof ThreadDeath) {
- throw (ThreadDeath) cause;
- }
- if (cause instanceof VirtualMachineError) {
- throw (VirtualMachineError) cause;
- }
- }
- logger.warn("Unable to create statement proxy for slow query report.", x);
- }
- return statement;
- }
-
- /**
- * Creates a proxy for a Statement.
- *
- * @param proxy The proxy object on which the method that triggered
- * the creation of the statement was called.
- * @param method The method that was called on the proxy
- * @param args The arguments passed as part of the method call to
- * the proxy
- * @param statement The statement object that is to be proxied
- * @param constructor The constructor for the desired proxy
- * @param sql The sql of of the statement
- *
- * @return A new proxy for the Statement
- * @throws InstantiationException Couldn't instantiate object
- * @throws IllegalAccessException Inaccessible constructor
- * @throws InvocationTargetException Exception thrown from constructor
- */
- protected Object createDecorator(Object proxy, Method method, Object[] args,
- Object statement, Constructor<?> constructor, String sql)
- throws InstantiationException, IllegalAccessException, InvocationTargetException {
- Object result = null;
- StatementProxy<Statement> statementProxy =
- new StatementProxy<>((Statement)statement,sql);
- result = constructor.newInstance(new Object[] { statementProxy });
- statementProxy.setActualProxy(result);
- statementProxy.setConnection(proxy);
- statementProxy.setConstructor(constructor);
- return result;
- }
-
- protected boolean isExecuteQuery(String methodName) {
- return EXECUTE_QUERY.equals(methodName);
- }
-
- protected boolean isExecuteQuery(Method method) {
- return isExecuteQuery(method.getName());
- }
-
- protected boolean isResultSet(Method method, boolean process) {
- return process(RESULTSET_TYPES, method, process);
- }
-
- /**
- * Class to measure query execute time.
- */
- protected class StatementProxy<T extends java.sql.Statement> implements InvocationHandler {
-
- protected boolean closed = false;
- protected T delegate;
- private Object actualProxy;
- private Object connection;
- private String sql;
- private Constructor<?> constructor;
-
- public StatementProxy(T delegate, String sql) {
- this.delegate = delegate;
- this.sql = sql;
- }
- public T getDelegate() {
- return this.delegate;
- }
-
- public String getSql() {
- return sql;
- }
-
- public void setConnection(Object proxy) {
- this.connection = proxy;
- }
- public Object getConnection() {
- return this.connection;
- }
-
- public void setActualProxy(Object proxy){
- this.actualProxy = proxy;
- }
- public Object getActualProxy() {
- return this.actualProxy;
- }
-
-
- public Constructor<?> getConstructor() {
- return constructor;
- }
- public void setConstructor(Constructor<?> constructor) {
- this.constructor = constructor;
- }
- public void closeInvoked() {
- if (getDelegate()!=null) {
- try {
- getDelegate().close();
- }catch (SQLException ignore) {
- }
- }
- closed = true;
- delegate = null;
- }
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- if (compare(TOSTRING_VAL,method)) {
- return toString();
- }
- // was close invoked?
- boolean close = compare(CLOSE_VAL, method);
- // allow close to be called multiple times
- if (close && closed)
- return null;
- // are we calling isClosed?
- if (compare(ISCLOSED_VAL, method))
- return Boolean.valueOf(closed);
- // if we are calling anything else, bail out
- if (closed)
- throw new SQLException("Statement closed.");
- if (compare(GETCONNECTION_VAL,method)){
- return connection;
- }
- boolean process = false;
- process = isResultSet(method, process);
- // check to see if we are about to execute a query
- // if we are executing, get the current time
- Object result = null;
- try {
- // perform close cleanup
- if (close) {
- closeInvoked();
- } else {
- // execute the query
- result = method.invoke(delegate, args);
- }
- } catch (Throwable t) {
- if (t instanceof InvocationTargetException
- && t.getCause() != null) {
- throw t.getCause();
- } else {
- throw t;
- }
- }
- if (process && result != null) {
- Constructor<?> cons = getResultSetConstructor();
- result = cons.newInstance(new Object[]{new ResultSetProxy(actualProxy, result)});
- }
- return result;
- }
-
- @Override
- public String toString() {
- StringBuffer buf = new StringBuffer(StatementProxy.class.getName());
- buf.append("[Proxy=");
- buf.append(System.identityHashCode(this));
- buf.append("; Sql=");
- buf.append(getSql());
- buf.append("; Delegate=");
- buf.append(getDelegate());
- buf.append("; Connection=");
- buf.append(getConnection());
- buf.append("]");
- return buf.toString();
- }
- }
-
- protected class ResultSetProxy implements InvocationHandler {
-
- private Object st;
- private Object delegate;
-
- public ResultSetProxy(Object st, Object delegate) {
- this.st = st;
- this.delegate = delegate;
- }
-
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- if (method.getName().equals("getStatement")) {
- return this.st;
- } else {
- try {
- return method.invoke(this.delegate, args);
- } catch (Throwable t) {
- if (t instanceof InvocationTargetException
- && t.getCause() != null) {
- throw t.getCause();
- } else {
- throw t;
- }
- }
- }
- }
- }
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool.interceptor;
-
-import java.lang.ref.WeakReference;
-import java.lang.reflect.Method;
-import java.sql.Statement;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.ConnectionPool;
-import org.apache.tomcat.jdbc.pool.PoolProperties;
-import org.apache.tomcat.jdbc.pool.PooledConnection;
-
-/**
- * Keeps track of statements associated with a connection and invokes close upon {@link java.sql.Connection#close()}
- * Useful for applications that dont close the associated statements after being done with a connection.
- *
- */
-public class StatementFinalizer extends AbstractCreateStatementInterceptor {
- private static final Log log = LogFactory.getLog(StatementFinalizer.class);
-
- protected List<StatementEntry> statements = new LinkedList<>();
-
- private boolean logCreationStack = false;
-
- @Override
- public Object createStatement(Object proxy, Method method, Object[] args, Object statement, long time) {
- try {
- if (statement instanceof Statement)
- statements.add(new StatementEntry((Statement)statement));
- }catch (ClassCastException x) {
- //ignore this one
- }
- return statement;
- }
-
- @SuppressWarnings("null") // st is not null when used
- @Override
- public void closeInvoked() {
- while (statements.size()>0) {
- StatementEntry ws = statements.remove(0);
- Statement st = ws.getStatement();
- boolean shallClose = false;
- try {
- shallClose = st!=null && (!st.isClosed());
- if (shallClose) {
- st.close();
- }
- } catch (Exception ignore) {
- if (log.isDebugEnabled()) {
- log.debug("Unable to closed statement upon connection close.",ignore);
- }
- } finally {
- if (logCreationStack && shallClose) {
- log.warn("Statement created, but was not closed at:", ws.getAllocationStack());
- }
- }
- }
- }
-
- @Override
- public void setProperties(Map<String, PoolProperties.InterceptorProperty> properties) {
- super.setProperties(properties);
-
- PoolProperties.InterceptorProperty logProperty = properties.get("trace");
- if (null != logProperty) {
- logCreationStack = logProperty.getValueAsBoolean(logCreationStack);
- }
- }
-
- @Override
- public void reset(ConnectionPool parent, PooledConnection con) {
- statements.clear();
- super.reset(parent, con);
- }
-
- protected class StatementEntry {
- private WeakReference<Statement> statement;
- private Throwable allocationStack;
-
- public StatementEntry(Statement statement) {
- this.statement = new WeakReference<>(statement);
- if (logCreationStack) {
- this.allocationStack = new Throwable();
- }
- }
-
- public Statement getStatement() {
- return statement.get();
- }
-
- public Throwable getAllocationStack() {
- return allocationStack;
- }
- }
-
-
-}
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- ============LICENSE_START=======================================================
- openecomp
- ================================================================================
- Copyright (C) 2016 - 2017 AT&T
- ================================================================================
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
- ============LICENSE_END=========================================================
- -->
-
-<!--
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements. See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<mbeans-descriptors>
-
- <mbean description="Reports " domain="tomcat.jdbc" group="jdbc-pool" name="SlowQueryReportJmx"
- type="org.apache.tomcat.jdbc.pool.interceptor.SlowQueryReportJmx">
-
- <attribute description="The name of the connection pool this Jmx bean is representing" name="poolName" type="java.lang.String" writeable="false"/>
- <attribute description="List of all registered connections pools" name="poolNames" type="[java.lang.String;" writeable="false"/>
- <attribute description="All the recorded query stats. " name="slowQueriesCD" type="[javax.management.openmbean.CompositeData;" writeable="false"/>
- <operation description="Clears all the query stats" impact="ACTION" name="resetStats" returnType="void"/>
-
- <notification description="Notification sent out by the slow query report when a query exceeds the threshold" name="slow-query">
- <notification-type>Slow query</notification-type>
- </notification>
-
- <notification description="Notification sent out by the slow query report when a query fails execution" name="failed-query">
- <notification-type>Failed query execution</notification-type>
- </notification>
- </mbean>
-</mbeans-descriptors>
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool.jmx;
-
-import java.util.Properties;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import javax.management.MBeanNotificationInfo;
-import javax.management.Notification;
-import javax.management.NotificationBroadcasterSupport;
-import javax.management.NotificationListener;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.jdbc.pool.PoolConfiguration;
-import org.apache.tomcat.jdbc.pool.PoolProperties.InterceptorDefinition;
-import org.apache.tomcat.jdbc.pool.PoolUtilities;
-import org.apache.tomcat.jdbc.pool.Validator;
-
-public class ConnectionPool extends NotificationBroadcasterSupport implements ConnectionPoolMBean {
- /**
- * logger
- */
- private static final Log log = LogFactory.getLog(ConnectionPool.class);
-
- /**
- * the connection pool
- */
- protected org.apache.tomcat.jdbc.pool.ConnectionPool pool = null;
- /**
- * sequence for JMX notifications
- */
- protected AtomicInteger sequence = new AtomicInteger(0);
-
- /**
- * Listeners that are local and interested in our notifications, no need for JMX
- */
- protected ConcurrentLinkedQueue<NotificationListener> listeners =
- new ConcurrentLinkedQueue<>();
-
- public ConnectionPool(org.apache.tomcat.jdbc.pool.ConnectionPool pool) {
- super();
- this.pool = pool;
- }
-
- public org.apache.tomcat.jdbc.pool.ConnectionPool getPool() {
- return pool;
- }
-
- public PoolConfiguration getPoolProperties() {
- return pool.getPoolProperties();
- }
-
- //=================================================================
- // NOTIFICATION INFO
- //=================================================================
- public static final String NOTIFY_INIT = "INIT FAILED";
- public static final String NOTIFY_CONNECT = "CONNECTION FAILED";
- public static final String NOTIFY_ABANDON = "CONNECTION ABANDONED";
- public static final String SLOW_QUERY_NOTIFICATION = "SLOW QUERY";
- public static final String FAILED_QUERY_NOTIFICATION = "FAILED QUERY";
- public static final String SUSPECT_ABANDONED_NOTIFICATION = "SUSPECT CONNECTION ABANDONED";
- public static final String POOL_EMPTY = "POOL EMPTY";
- public static final String SUSPECT_RETURNED_NOTIFICATION = "SUSPECT CONNECTION RETURNED";
-
- @Override
- public MBeanNotificationInfo[] getNotificationInfo() {
- MBeanNotificationInfo[] pres = super.getNotificationInfo();
- MBeanNotificationInfo[] loc = getDefaultNotificationInfo();
- MBeanNotificationInfo[] aug = new MBeanNotificationInfo[pres.length + loc.length];
- if (pres.length>0) System.arraycopy(pres, 0, aug, 0, pres.length);
- if (loc.length >0) System.arraycopy(loc, 0, aug, pres.length, loc.length);
- return aug;
- }
-
- public static MBeanNotificationInfo[] getDefaultNotificationInfo() {
- String[] types = new String[] {NOTIFY_INIT, NOTIFY_CONNECT, NOTIFY_ABANDON, SLOW_QUERY_NOTIFICATION,
- FAILED_QUERY_NOTIFICATION, SUSPECT_ABANDONED_NOTIFICATION, POOL_EMPTY, SUSPECT_RETURNED_NOTIFICATION};
- String name = Notification.class.getName();
- String description = "A connection pool error condition was met.";
- MBeanNotificationInfo info = new MBeanNotificationInfo(types, name, description);
- return new MBeanNotificationInfo[] {info};
- }
-
- /**
- * Return true if the notification was sent successfully, false otherwise.
- * @param type The notification type
- * @param message The message
- * @return true if the notification succeeded
- */
- public boolean notify(final String type, String message) {
- try {
- Notification n = new Notification(
- type,
- this,
- sequence.incrementAndGet(),
- System.currentTimeMillis(),
- "["+type+"] "+message);
- sendNotification(n);
- for (NotificationListener listener : listeners) {
- listener.handleNotification(n,this);
- }
- return true;
- }catch (Exception x) {
- if (log.isDebugEnabled()) {
- log.debug("Notify failed. Type="+type+"; Message="+message,x);
- }
- return false;
- }
-
- }
-
- public void addListener(NotificationListener list) {
- listeners.add(list);
- }
-
- public boolean removeListener(NotificationListener list) {
- return listeners.remove(list);
- }
-
- //=================================================================
- // POOL STATS
- //=================================================================
-
- @Override
- public int getSize() {
- return pool.getSize();
- }
-
- @Override
- public int getIdle() {
- return pool.getIdle();
- }
-
- @Override
- public int getActive() {
- return pool.getActive();
- }
-
- @Override
- public int getNumIdle() {
- return getIdle();
- }
-
- @Override
- public int getNumActive() {
- return getActive();
- }
-
- @Override
- public int getWaitCount() {
- return pool.getWaitCount();
- }
-
- @Override
- public long getBorrowedCount() {
- return pool.getBorrowedCount();
- }
-
- @Override
- public long getReturnedCount() {
- return pool.getReturnedCount();
- }
-
- @Override
- public long getCreatedCount() {
- return pool.getCreatedCount();
- }
-
- @Override
- public long getReleasedCount() {
- return pool.getReleasedCount();
- }
-
- @Override
- public long getReconnectedCount() {
- return pool.getReconnectedCount();
- }
-
- @Override
- public long getRemoveAbandonedCount() {
- return pool.getRemoveAbandonedCount();
- }
-
- @Override
- public long getReleasedIdleCount() {
- return pool.getReleasedIdleCount();
- }
-
- //=================================================================
- // POOL OPERATIONS
- //=================================================================
- @Override
- public void checkIdle() {
- pool.checkIdle();
- }
-
- @Override
- public void checkAbandoned() {
- pool.checkAbandoned();
- }
-
- @Override
- public void testIdle() {
- pool.testAllIdle();
- }
-
- @Override
- public void resetStats() {
- pool.resetStats();
- }
-
- //=================================================================
- // POOL PROPERTIES
- //=================================================================
- //=========================================================
- // PROPERTIES / CONFIGURATION
- //=========================================================
-
-
- @Override
- public String getConnectionProperties() {
- return getPoolProperties().getConnectionProperties();
- }
-
- @Override
- public Properties getDbProperties() {
- return PoolUtilities.cloneWithoutPassword(getPoolProperties().getDbProperties());
- }
-
- @Override
- public String getDefaultCatalog() {
- return getPoolProperties().getDefaultCatalog();
- }
-
- @Override
- public int getDefaultTransactionIsolation() {
- return getPoolProperties().getDefaultTransactionIsolation();
- }
-
- @Override
- public String getDriverClassName() {
- return getPoolProperties().getDriverClassName();
- }
-
-
- @Override
- public int getInitialSize() {
- return getPoolProperties().getInitialSize();
- }
-
- @Override
- public String getInitSQL() {
- return getPoolProperties().getInitSQL();
- }
-
- @Override
- public String getJdbcInterceptors() {
- return getPoolProperties().getJdbcInterceptors();
- }
-
- @Override
- public int getMaxActive() {
- return getPoolProperties().getMaxActive();
- }
-
- @Override
- public int getMaxIdle() {
- return getPoolProperties().getMaxIdle();
- }
-
- @Override
- public int getMaxWait() {
- return getPoolProperties().getMaxWait();
- }
-
- @Override
- public int getMinEvictableIdleTimeMillis() {
- return getPoolProperties().getMinEvictableIdleTimeMillis();
- }
-
- @Override
- public int getMinIdle() {
- return getPoolProperties().getMinIdle();
- }
-
- @Override
- public long getMaxAge() {
- return getPoolProperties().getMaxAge();
- }
-
- @Override
- public String getName() {
- return this.getPoolName();
- }
-
- @Override
- public int getNumTestsPerEvictionRun() {
- return getPoolProperties().getNumTestsPerEvictionRun();
- }
-
- /**
- * @return DOES NOT RETURN THE PASSWORD, IT WOULD SHOW UP IN JMX
- */
- @Override
- public String getPassword() {
- return "Password not available as DataSource/JMX operation.";
- }
-
- @Override
- public int getRemoveAbandonedTimeout() {
- return getPoolProperties().getRemoveAbandonedTimeout();
- }
-
-
- @Override
- public int getTimeBetweenEvictionRunsMillis() {
- return getPoolProperties().getTimeBetweenEvictionRunsMillis();
- }
-
- @Override
- public String getUrl() {
- return getPoolProperties().getUrl();
- }
-
- @Override
- public String getUsername() {
- return getPoolProperties().getUsername();
- }
-
- @Override
- public long getValidationInterval() {
- return getPoolProperties().getValidationInterval();
- }
-
- @Override
- public String getValidationQuery() {
- return getPoolProperties().getValidationQuery();
- }
-
- @Override
- public int getValidationQueryTimeout() {
- return getPoolProperties().getValidationQueryTimeout();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public String getValidatorClassName() {
- return getPoolProperties().getValidatorClassName();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public Validator getValidator() {
- return getPoolProperties().getValidator();
- }
-
- @Override
- public boolean isAccessToUnderlyingConnectionAllowed() {
- return getPoolProperties().isAccessToUnderlyingConnectionAllowed();
- }
-
- @Override
- public Boolean isDefaultAutoCommit() {
- return getPoolProperties().isDefaultAutoCommit();
- }
-
- @Override
- public Boolean isDefaultReadOnly() {
- return getPoolProperties().isDefaultReadOnly();
- }
-
- @Override
- public boolean isLogAbandoned() {
- return getPoolProperties().isLogAbandoned();
- }
-
- @Override
- public boolean isPoolSweeperEnabled() {
- return getPoolProperties().isPoolSweeperEnabled();
- }
-
- @Override
- public boolean isRemoveAbandoned() {
- return getPoolProperties().isRemoveAbandoned();
- }
-
- @Override
- public int getAbandonWhenPercentageFull() {
- return getPoolProperties().getAbandonWhenPercentageFull();
- }
-
- @Override
- public boolean isTestOnBorrow() {
- return getPoolProperties().isTestOnBorrow();
- }
-
- @Override
- public boolean isTestOnConnect() {
- return getPoolProperties().isTestOnConnect();
- }
-
- @Override
- public boolean isTestOnReturn() {
- return getPoolProperties().isTestOnReturn();
- }
-
- @Override
- public boolean isTestWhileIdle() {
- return getPoolProperties().isTestWhileIdle();
- }
-
-
- @Override
- public Boolean getDefaultAutoCommit() {
- return getPoolProperties().getDefaultAutoCommit();
- }
-
- @Override
- public Boolean getDefaultReadOnly() {
- return getPoolProperties().getDefaultReadOnly();
- }
-
- @Override
- public InterceptorDefinition[] getJdbcInterceptorsAsArray() {
- return getPoolProperties().getJdbcInterceptorsAsArray();
- }
-
- @Override
- public boolean getUseLock() {
- return getPoolProperties().getUseLock();
- }
-
- @Override
- public boolean isFairQueue() {
- return getPoolProperties().isFairQueue();
- }
-
- @Override
- public boolean isJmxEnabled() {
- return getPoolProperties().isJmxEnabled();
- }
-
- @Override
- public boolean isUseEquals() {
- return getPoolProperties().isUseEquals();
- }
-
- @Override
- public void setAbandonWhenPercentageFull(int percentage) {
- getPoolProperties().setAbandonWhenPercentageFull(percentage);
- }
-
- @Override
- public void setAccessToUnderlyingConnectionAllowed(boolean accessToUnderlyingConnectionAllowed) {
- getPoolProperties().setAccessToUnderlyingConnectionAllowed(accessToUnderlyingConnectionAllowed);
- }
-
- @Override
- public void setDbProperties(Properties dbProperties) {
- getPoolProperties().setDbProperties(dbProperties);
- }
-
- @Override
- public void setDefaultReadOnly(Boolean defaultReadOnly) {
- getPoolProperties().setDefaultReadOnly(defaultReadOnly);
- }
-
- @Override
- public void setMaxAge(long maxAge) {
- getPoolProperties().setMaxAge(maxAge);
- }
-
- @Override
- public void setName(String name) {
- getPoolProperties().setName(name);
- }
-
- @Override
- public String getPoolName() {
- return getPoolProperties().getName();
- }
-
-
- @Override
- public void setConnectionProperties(String connectionProperties) {
- getPoolProperties().setConnectionProperties(connectionProperties);
-
- }
-
- @Override
- public void setDefaultAutoCommit(Boolean defaultAutoCommit) {
- getPoolProperties().setDefaultAutoCommit(defaultAutoCommit);
- }
-
- @Override
- public void setDefaultCatalog(String defaultCatalog) {
- getPoolProperties().setDefaultCatalog(defaultCatalog);
- }
-
- @Override
- public void setDefaultTransactionIsolation(int defaultTransactionIsolation) {
- getPoolProperties().setDefaultTransactionIsolation(defaultTransactionIsolation);
- }
-
- @Override
- public void setDriverClassName(String driverClassName) {
- getPoolProperties().setDriverClassName(driverClassName);
- }
-
-
- @Override
- public void setFairQueue(boolean fairQueue) {
- // noop - this pool is already running
- throw new UnsupportedOperationException();
- }
-
-
- @Override
- public void setInitialSize(int initialSize) {
- // noop - this pool is already running
- throw new UnsupportedOperationException();
-
- }
-
-
- @Override
- public void setInitSQL(String initSQL) {
- getPoolProperties().setInitSQL(initSQL);
-
- }
-
-
- @Override
- public void setJdbcInterceptors(String jdbcInterceptors) {
- // noop - this pool is already running
- throw new UnsupportedOperationException();
- }
-
-
- @Override
- public void setJmxEnabled(boolean jmxEnabled) {
- // noop - this pool is already running and obviously jmx enabled
- throw new UnsupportedOperationException();
- }
-
-
- @Override
- public void setLogAbandoned(boolean logAbandoned) {
- getPoolProperties().setLogAbandoned(logAbandoned);
- }
-
-
- @Override
- public void setMaxActive(int maxActive) {
- getPoolProperties().setMaxActive(maxActive);
- //make sure the pool is properly configured
- pool.checkPoolConfiguration(getPoolProperties());
- }
-
-
- @Override
- public void setMaxIdle(int maxIdle) {
- getPoolProperties().setMaxIdle(maxIdle);
- //make sure the pool is properly configured
- pool.checkPoolConfiguration(getPoolProperties());
-
- }
-
-
- @Override
- public void setMaxWait(int maxWait) {
- getPoolProperties().setMaxWait(maxWait);
- }
-
-
- @Override
- public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
- boolean wasEnabled = getPoolProperties().isPoolSweeperEnabled();
- getPoolProperties().setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
- boolean shouldBeEnabled = getPoolProperties().isPoolSweeperEnabled();
- //make sure pool cleaner starts/stops when it should
- if (!wasEnabled && shouldBeEnabled) pool.initializePoolCleaner(getPoolProperties());
- else if (wasEnabled && !shouldBeEnabled) pool.terminatePoolCleaner();
- }
-
-
- @Override
- public void setMinIdle(int minIdle) {
- getPoolProperties().setMinIdle(minIdle);
- //make sure the pool is properly configured
- pool.checkPoolConfiguration(getPoolProperties());
- }
-
-
- @Override
- public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {
- getPoolProperties().setNumTestsPerEvictionRun(numTestsPerEvictionRun);
- }
-
-
- @Override
- public void setPassword(String password) {
- getPoolProperties().setPassword(password);
- }
-
-
- @Override
- public void setRemoveAbandoned(boolean removeAbandoned) {
- boolean wasEnabled = getPoolProperties().isPoolSweeperEnabled();
- getPoolProperties().setRemoveAbandoned(removeAbandoned);
- boolean shouldBeEnabled = getPoolProperties().isPoolSweeperEnabled();
- //make sure pool cleaner starts/stops when it should
- if (!wasEnabled && shouldBeEnabled) pool.initializePoolCleaner(getPoolProperties());
- else if (wasEnabled && !shouldBeEnabled) pool.terminatePoolCleaner();
- }
-
-
- @Override
- public void setRemoveAbandonedTimeout(int removeAbandonedTimeout) {
- boolean wasEnabled = getPoolProperties().isPoolSweeperEnabled();
- getPoolProperties().setRemoveAbandonedTimeout(removeAbandonedTimeout);
- boolean shouldBeEnabled = getPoolProperties().isPoolSweeperEnabled();
- //make sure pool cleaner starts/stops when it should
- if (!wasEnabled && shouldBeEnabled) pool.initializePoolCleaner(getPoolProperties());
- else if (wasEnabled && !shouldBeEnabled) pool.terminatePoolCleaner();
- }
-
-
- @Override
- public void setTestOnBorrow(boolean testOnBorrow) {
- getPoolProperties().setTestOnBorrow(testOnBorrow);
- }
-
-
- @Override
- public void setTestOnConnect(boolean testOnConnect) {
- getPoolProperties().setTestOnConnect(testOnConnect);
- }
-
-
- @Override
- public void setTestOnReturn(boolean testOnReturn) {
- getPoolProperties().setTestOnReturn(testOnReturn);
- }
-
-
- @Override
- public void setTestWhileIdle(boolean testWhileIdle) {
- boolean wasEnabled = getPoolProperties().isPoolSweeperEnabled();
- getPoolProperties().setTestWhileIdle(testWhileIdle);
- boolean shouldBeEnabled = getPoolProperties().isPoolSweeperEnabled();
- //make sure pool cleaner starts/stops when it should
- if (!wasEnabled && shouldBeEnabled) pool.initializePoolCleaner(getPoolProperties());
- else if (wasEnabled && !shouldBeEnabled) pool.terminatePoolCleaner();
- }
-
-
- @Override
- public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
- boolean wasEnabled = getPoolProperties().isPoolSweeperEnabled();
- getPoolProperties().setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
- boolean shouldBeEnabled = getPoolProperties().isPoolSweeperEnabled();
- //make sure pool cleaner starts/stops when it should
- if (!wasEnabled && shouldBeEnabled) {
- pool.initializePoolCleaner(getPoolProperties());
- } else if (wasEnabled) {
- pool.terminatePoolCleaner();
- if (shouldBeEnabled) {
- pool.initializePoolCleaner(getPoolProperties());
- }
- }
- }
-
-
- @Override
- public void setUrl(String url) {
- getPoolProperties().setUrl(url);
- }
-
-
- @Override
- public void setUseEquals(boolean useEquals) {
- getPoolProperties().setUseEquals(useEquals);
- }
-
-
- @Override
- public void setUseLock(boolean useLock) {
- getPoolProperties().setUseLock(useLock);
- }
-
-
- @Override
- public void setUsername(String username) {
- getPoolProperties().setUsername(username);
- }
-
-
- @Override
- public void setValidationInterval(long validationInterval) {
- getPoolProperties().setValidationInterval(validationInterval);
- }
-
-
- @Override
- public void setValidationQuery(String validationQuery) {
- getPoolProperties().setValidationQuery(validationQuery);
- }
-
- @Override
- public void setValidationQueryTimeout(int validationQueryTimeout) {
- getPoolProperties().setValidationQueryTimeout(validationQueryTimeout);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setValidatorClassName(String className) {
- getPoolProperties().setValidatorClassName(className);
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public int getSuspectTimeout() {
- return getPoolProperties().getSuspectTimeout();
- }
-
- /**
- * {@inheritDoc}
- */
-
- @Override
- public void setSuspectTimeout(int seconds) {
- getPoolProperties().setSuspectTimeout(seconds);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setDataSource(Object ds) {
- getPoolProperties().setDataSource(ds);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Object getDataSource() {
- return getPoolProperties().getDataSource();
- }
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setDataSourceJNDI(String jndiDS) {
- getPoolProperties().setDataSourceJNDI(jndiDS);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public String getDataSourceJNDI() {
- return getPoolProperties().getDataSourceJNDI();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isAlternateUsernameAllowed() {
- return getPoolProperties().isAlternateUsernameAllowed();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setAlternateUsernameAllowed(boolean alternateUsernameAllowed) {
- getPoolProperties().setAlternateUsernameAllowed(alternateUsernameAllowed);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setValidator(Validator validator) {
- getPoolProperties().setValidator(validator);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setCommitOnReturn(boolean commitOnReturn) {
- getPoolProperties().setCommitOnReturn(commitOnReturn);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getCommitOnReturn() {
- return getPoolProperties().getCommitOnReturn();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setRollbackOnReturn(boolean rollbackOnReturn) {
- getPoolProperties().setRollbackOnReturn(rollbackOnReturn);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getRollbackOnReturn() {
- return getPoolProperties().getRollbackOnReturn();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setUseDisposableConnectionFacade(boolean useDisposableConnectionFacade) {
- getPoolProperties().setUseDisposableConnectionFacade(useDisposableConnectionFacade);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getUseDisposableConnectionFacade() {
- return getPoolProperties().getUseDisposableConnectionFacade();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setLogValidationErrors(boolean logValidationErrors) {
- getPoolProperties().setLogValidationErrors(logValidationErrors);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getLogValidationErrors() {
- return getPoolProperties().getLogValidationErrors();
- }
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean getPropagateInterruptState() {
- return getPoolProperties().getPropagateInterruptState();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setPropagateInterruptState(boolean propagateInterruptState) {
- getPoolProperties().setPropagateInterruptState(propagateInterruptState);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean isIgnoreExceptionOnPreLoad() {
- return getPoolProperties().isIgnoreExceptionOnPreLoad();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void setIgnoreExceptionOnPreLoad(boolean ignoreExceptionOnPreLoad) {
- // noop - this pool is already running
- throw new UnsupportedOperationException();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void purge() {
- pool.purge();
-
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void purgeOnReturn() {
- pool.purgeOnReturn();
-
- }
-
-
-
-
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-/* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.tomcat.jdbc.pool.jmx;
-
-import org.apache.tomcat.jdbc.pool.PoolConfiguration;
-
-public interface ConnectionPoolMBean extends PoolConfiguration {
-
- //=================================================================
- // POOL STATS
- //=================================================================
-
- public int getSize();
-
- public int getIdle();
-
- public int getActive();
-
- public int getNumIdle();
-
- public int getNumActive();
-
- public int getWaitCount();
-
- public long getBorrowedCount();
-
- public long getReturnedCount();
-
- public long getCreatedCount();
-
- public long getReleasedCount();
-
- public long getReconnectedCount();
-
- public long getRemoveAbandonedCount();
-
- public long getReleasedIdleCount();
-
- //=================================================================
- // POOL OPERATIONS
- //=================================================================
- public void checkIdle();
-
- public void checkAbandoned();
-
- public void testIdle();
-
- /**
- * Purges all connections in the pool.
- * For connections currently in use, these connections will be
- * purged when returned on the pool. This call also
- * purges connections that are idle and in the pool
- * To only purge used/active connections see {@link #purgeOnReturn()}
- */
- public void purge();
-
- /**
- * Purges connections when they are returned from the pool.
- * This call does not purge idle connections until they are used.
- * To purge idle connections see {@link #purge()}
- */
- public void purgeOnReturn();
-
- /**
- * reset the statistics of this pool.
- */
- public void resetStats();
-
- //=================================================================
- // POOL NOTIFICATIONS
- //=================================================================
-
-
-}
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- ============LICENSE_START=======================================================
- openecomp
- ================================================================================
- Copyright (C) 2016 - 2017 AT&T
- ================================================================================
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
- ============LICENSE_END=========================================================
- -->
-
-<!--
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements. See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<mbeans-descriptors>
-
- <mbean name="TomcatJDBCPool"
- description="Provides per diagnostic metrics and notifications for JDBC operations"
- domain="tomcat"
- group="jdbc"
- type="org.apache.tomcat.jdbc.pool.DataSource">
-
- <attribute name="className"
- description="Fully qualified class name of the managed object"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="size"
- description="The number of established connections in the pool, idle and in use"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="idle"
- description="The number of established connections in the pool that are idle"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="numIdle"
- description="Same as the idle attribute"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="active"
- description="The number of established connections in the pool that are in use"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="numActive"
- description="Same as the active attribute"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="poolSweeperEnabled"
- description="Returns true if the pool has a background thread running"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="url"
- description="The JDBC url for this connection pool"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="driverClassName"
- description="The JDBC driver class for this connection pool"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="defaultAutoCommit"
- description="The JDBC auto commit setting for new connections"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="defaultReadOnly"
- description="The JDBC read only setting for new connections"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="defaultTransactionIsolation"
- description="The JDBC transaction isolation setting for new connections"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="connectionProperties"
- description="The connection properties that will be set for new connections. Format of the string will be [propertyName=property;]*"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="defaultCatalog"
- description="The JDBC transaction isolation setting for new connections"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="initialSize"
- description="The number of connections opened at pool startup"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="maxActive"
- description="The maximum number of open connections"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="maxIdle"
- description="The max number of idle connections"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="minIdle"
- description="The minimum number of open connections"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="maxWait"
- description="The time to wait in milliseconds before a SQLException is thrown when a connection is requested"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="validationQuery"
- description="The query to run during validation"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="validationQueryTimeout"
- description="The timeout in seconds before a connection validation queries fail"
- type="java.lang.Integer"
- writeable="false" />
-
- <attribute name="testOnBorrow"
- description="True if validation happens when a connection is requested"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="testOnReturn"
- description="True if validation happens when a connection is returned"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="testWhileIdle"
- description="True if validation happens when a connection is not in use (idle)"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="timeBetweenEvictionRunsMillis"
- description="Sleep time for background thread in between pool checks"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="numTestsPerEvictionRun"
- description="Not in use"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="minEvictableIdleTimeMillis"
- description="Minimum amount of time a connection stays idle before it is evicted"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="accessToUnderlyingConnectionAllowed"
- description="Returns true if one can retrieve the actual JDBC connection"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="removeAbandoned"
- description="Returns true if connection in use can be timed out"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="removeAbandonedTimeout"
- description="Timeout in seconds for connections in use"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="logAbandoned"
- description="If true, stack trace will be recorded and printed out for timed out connection"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="loginTimeout"
- description="Not in use"
- type="java.lang.Integer"
- writeable="false"/>
-
-
- <attribute name="name"
- description="The name of the connection pool, will be used in the ObjectName of the actual pool"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="password"
- description="For security purposes,this doesn't return anything"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="username"
- description="The username used to open connections"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="validationInterval"
- description="If larger than zero than validation will only occur after the interval milliseconds has passed"
- type="java.lang.Long"
- writeable="false"/>
-
- <attribute name="initSQL"
- description="A SQL executed once per connection, when it is established"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="testOnConnect"
- description="Validate connection after connection has been established"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="jdbcInterceptors"
- description="The interceptors configured for this pool"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="jmxEnabled"
- description="Register the pool with JMX or not"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="fairQueue"
- description="a fair queue is being used by the connection pool"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="abandonWhenPercentageFull"
- description="Connections that have been abandoned isn't closed unless connections in use are above this percentage"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="maxAge"
- description="Time in milliseconds to keep this connection alive even when used"
- type="java.lang.Long"
- writeable="false"/>
-
- <attribute name="useEquals"
- description="Set to true if you wish the ProxyConnection class to use String.equals and set to false when you wish to use == when comparing method names"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="useLock"
- description="If true, use a lock when operations are performed on the connection object"
- type="java.lang.Boolean"
- is="false"
- writeable="false"/>
-
- <attribute name="suspectTimeout"
- description="Timeout in seconds for connection that suspected to have been abandoned"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="rollbackOnReturn"
- description="If autoCommit==false then the pool can terminate the transaction by calling rollback on the connection as it is returned to the pool"
- type="java.lang.Boolean"
- is="false"
- writeable="false"/>
-
- <attribute name="commitOnReturn"
- description="If autoCommit==false then the pool can complete the transaction by calling commit on the connection as it is returned to the pool"
- type="java.lang.Boolean"
- is="false"
- writeable="false"/>
-
- <attribute name="alternateUsernameAllowed"
- description="If true, getConnection(username,password) is allowed"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="dataSource"
- description="Data source that is injected into the pool"
- type="javax.sql.DataSource"
- writeable="false"/>
-
- <attribute name="dataSourceJNDI"
- description="The JNDI name for a data source to be looked up"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="useDisposableConnectionFacade"
- description="If true, connection pool is configured to use a connection facade to prevent re-use of connection after close() has been invoked"
- type="java.lang.Boolean"
- is="false"
- writeable="false"/>
-
- <attribute name="logValidationErrors"
- description="Log errors during the validation phase to the log file"
- type="java.lang.Boolean"
- is="false"
- writeable="false"/>
-
- <attribute name="validatorClassName"
- description="The name of validator class which implements org.apache.tomcat.jdbc.pool.Validator interface"
- type="java.lang.String"
- writeable="false"/>
-
- <attribute name="waitCount"
- description="The number of threads waiting for a connection"
- type="java.lang.Integer"
- writeable="false"/>
-
- <attribute name="propagateInterruptState"
- description="If true, propagate the interrupt state for a thread that has been interrupted"
- type="java.lang.Boolean"
- is="false"
- writeable="false"/>
-
- <attribute name="ignoreExceptionOnPreLoad"
- description="If true, ignore error of connection creation while initializing the pool"
- type="java.lang.Boolean"
- is="true"
- writeable="false"/>
-
- <attribute name="borrowedCount"
- description="The total number of connections borrowed from this pool"
- type="java.lang.Long"
- writeable="false"/>
-
- <attribute name="createdCount"
- description="The total number of connections created by this pool"
- type="java.lang.Long"
- writeable="false"/>
-
- <attribute name="returnedCount"
- description="The total number of connections returned to this pool"
- type="java.lang.Long"
- writeable="false"/>
-
- <attribute name="releasedCount"
- description="The total number of connections released from this pool"
- type="java.lang.Long"
- writeable="false"/>
-
- <attribute name="reconnectedCount"
- description="The total number of connections reconnected by this pool."
- type="java.lang.Long"
- writeable="false"/>
-
- <attribute name="removeAbandonedCount"
- description="The total number of connections released by remove abandoned."
- type="java.lang.Long"
- writeable="false"/>
-
- <attribute name="releasedIdleCount"
- description="The total number of connections released by eviction."
- type="java.lang.Long"
- writeable="false"/>
-
- <operation name="checkIdle"
- description="forces a check of idle connections"
- impact="ACTION"
- returnType="void" />
-
- <operation name="checkAbandoned"
- description="forces a check of abandoned connections"
- impact="ACTION"
- returnType="void" />
-
- <operation name="testIdle"
- description="forces a validation of abandoned connections"
- impact="ACTION"
- returnType="void" />
-
- <operation name="purge"
- description="Purges all connections in the pool"
- impact="ACTION"
- returnType="void" />
-
- <operation name="purgeOnReturn"
- description="Purges connections when they are returned from the pool"
- impact="ACTION"
- returnType="void" />
-
- <operation name="resetStats"
- description="reset the statistics of this pool."
- impact="ACTION"
- returnType="void" />
-
- </mbean>
-
-</mbeans-descriptors>
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * openecomp
- * ================================================================================
- * Copyright (C) 2016 - 2017 AT&T
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-package org.openecomp.sdnc.sli.resource.common;
-
-import org.osgi.framework.BundleActivator;
-import org.osgi.framework.BundleContext;
-
-public class CommonActivator implements BundleActivator {
-
- @Override
- public void start(BundleContext context) throws Exception {
- // TODO Auto-generated method stub
-
- }
-
- @Override
- public void stop(BundleContext context) throws Exception {
- // TODO Auto-generated method stub
-
- }
-
-}
<feature name='sdnc-dblib' description="sdnc-dblib" version='${project.version}'>
<!-- Most applications will have a dependency on the ODL MD-SAL Broker -->
<feature version="${odl.mdsal.version}">odl-mdsal-broker</feature>
- <bundle>mvn:org.openecomp.sdnc.core/dblib-common/${project.version}</bundle>
+ <bundle>mvn:org.apache.tomcat/tomcat-jdbc/${tomcat-jdbc.version}</bundle>
<bundle>mvn:org.openecomp.sdnc.core/dblib-provider/${project.version}</bundle>
<bundle>mvn:mysql/mysql-connector-java/${mysql.connector.version}</bundle>
</feature>
<name>AT&T</name>
</organization>
<modules>
- <module>common</module>
<module>provider</module>
<module>features</module>
<module>installer</module>
<artifactId>dblib-common</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.apache.tomcat</groupId>
+ <artifactId>tomcat-jdbc</artifactId>
+ <version>${tomcat-jdbc.version}</version>
+ </dependency>
</dependencies>
<build>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
} finally {
- if (request instanceof HttpServletRequest) {
+ if (request != null && request instanceof HttpServletRequest) {
t1 = System.currentTimeMillis();
private String decompressGZIPByteArray(byte[] bytes) {
+ BufferedReader in = null;
+ InputStreamReader inR = null;
+ ByteArrayInputStream byteS = null;
+ GZIPInputStream gzS = null;
StringBuilder str = new StringBuilder();
- try (ByteArrayInputStream byteS = new ByteArrayInputStream(bytes);
- GZIPInputStream gzS = new GZIPInputStream(byteS);
- InputStreamReader inR = new InputStreamReader(gzS);
- BufferedReader in = new BufferedReader(inR);) {
+ try {
+ byteS = new ByteArrayInputStream(bytes);
+ gzS = new GZIPInputStream(byteS);
+ inR = new InputStreamReader(gzS);
+ in = new BufferedReader(inR);
+
+ if (in != null) {
- String content;
+ String content;
- while ((content = in.readLine()) != null) {
- str.append(content);
+ while ((content = in.readLine()) != null) {
+ str.append(content);
+ }
}
} catch (Exception e) {
log.error("Failed get read GZIPInputStream", e);
- }
+ } finally {
+ if (byteS != null)
+ try {
+ byteS.close();
+ } catch (IOException e1) {
+ log.error("Failed to close ByteStream", e1);
+ }
+ if (gzS != null)
+ try {
+ gzS.close();
+ } catch (IOException e2) {
+ log.error("Failed to close GZStream", e2);
+ }
+ if (inR != null)
+ try {
+ inR.close();
+ } catch (IOException e3) {
+ log.error("Failed to close InputReader", e3);
+ }
+ if (in != null)
+ try {
+ in.close();
+ } catch (IOException e) {
+ log.error("Failed to close BufferedReader", e);
+ }
+ }
return str.toString();
}
}
<mysql.connector.version>5.1.39</mysql.connector.version>
<h2database.version>1.4.186</h2database.version>
+ <tomcat-jdbc.version>8.5.14</tomcat-jdbc.version>
</properties>
<modelVersion>4.0.0</modelVersion>
Code Review / sdnc / core.git / commitdiff