diff options
| author |   Dan Timoney <dtimoney@att.com> | 2017-03-31 15:03:13 -0400 |
|---|---|---|
| committer | Dan Timoney <dtimoney@att.com> | 2017-03-31 15:11:48 -0400 |
| commit | 974b67dd4021e6e839eaad25366bffe6d7a414c8 (patch) | |
| tree | c16b969e86323ed8b0914253b1c74d42d31a7ed1 /dblib | |
| parent | e0451f75b26082418757f279351c2d3e29c0a5c8 (diff) | |
[SDNC-5] Rebase sdnc-core
Upgrade to OpenDaylight Boron release, and sync changes made since 16.10 release to ONAP SDN-C distribution
Change-Id: I20bef9e6d0008c4436b5624ce839bbb70ecc20a5
Signed-off-by: Dan Timoney <dtimoney@att.com>
Diffstat (limited to 'dblib')
55 files changed, 15341 insertions, 349 deletions
diff --git a/dblib/common/LICENSE b/dblib/common/LICENSE new file mode 100755 index 0000000..f49a4e1 --- /dev/null +++ b/dblib/common/LICENSE @@ -0,0 +1,201 @@ + 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 diff --git a/dblib/common/NOTICE b/dblib/common/NOTICE new file mode 100755 index 0000000..0b6fc4b --- /dev/null +++ b/dblib/common/NOTICE @@ -0,0 +1,6 @@ +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/). + diff --git a/dblib/common/doc/changelog.xml b/dblib/common/doc/changelog.xml new file mode 100755 index 0000000..2d7ddf8 --- /dev/null +++ b/dblib/common/doc/changelog.xml @@ -0,0 +1,133 @@ +<?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> diff --git a/dblib/common/doc/jdbc-pool.xml b/dblib/common/doc/jdbc-pool.xml new file mode 100755 index 0000000..8d69624 --- /dev/null +++ b/dblib/common/doc/jdbc-pool.xml @@ -0,0 +1,988 @@ +<?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> diff --git a/dblib/common/doc/package.xsl b/dblib/common/doc/package.xsl new file mode 100755 index 0000000..cdadd53 --- /dev/null +++ b/dblib/common/doc/package.xsl @@ -0,0 +1,249 @@ +<?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> diff --git a/dblib/common/doc/project.xml b/dblib/common/doc/project.xml new file mode 100755 index 0000000..912903d --- /dev/null +++ b/dblib/common/doc/project.xml @@ -0,0 +1,31 @@ +<?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> + diff --git a/dblib/common/pom.xml b/dblib/common/pom.xml new file mode 100755 index 0000000..fa25c98 --- /dev/null +++ b/dblib/common/pom.xml @@ -0,0 +1,88 @@ +<?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.0-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> diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/naming/GenericNamingResourcesFactory.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/naming/GenericNamingResourcesFactory.java new file mode 100644 index 0000000..c6112a1 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/naming/GenericNamingResourcesFactory.java @@ -0,0 +1,254 @@ +/*- + * ============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); + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/ClassLoaderUtil.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/ClassLoaderUtil.java new file mode 100644 index 0000000..23b5668 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/ClassLoaderUtil.java @@ -0,0 +1,81 @@ +/*- + * ============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); + } + + + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/ConnectionPool.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/ConnectionPool.java new file mode 100644 index 0000000..7b081df --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/ConnectionPool.java @@ -0,0 +1,1500 @@ +/*- + * ============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); + } + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DataSource.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DataSource.java new file mode 100644 index 0000000..4922bf0 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DataSource.java @@ -0,0 +1,180 @@ +/*- + * ============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); + } + } + + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DataSourceFactory.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DataSourceFactory.java new file mode 100644 index 0000000..d0a5127 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DataSourceFactory.java @@ -0,0 +1,612 @@ +/*- + * ============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); + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DataSourceProxy.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DataSourceProxy.java new file mode 100644 index 0000000..3e9b8ae --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DataSourceProxy.java @@ -0,0 +1,1496 @@ +/*- + * ============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); + } + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DisposableConnectionFacade.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DisposableConnectionFacade.java new file mode 100644 index 0000000..ed0e9db --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/DisposableConnectionFacade.java @@ -0,0 +1,118 @@ +/*- + * ============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); + } + } + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/FairBlockingQueue.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/FairBlockingQueue.java new file mode 100644 index 0000000..c02bfa3 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/FairBlockingQueue.java @@ -0,0 +1,579 @@ +/*- + * ============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(); + } + } + + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/JdbcInterceptor.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/JdbcInterceptor.java new file mode 100644 index 0000000..46bc0b1 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/JdbcInterceptor.java @@ -0,0 +1,259 @@ +/*- + * ============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 + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/MultiLockFairBlockingQueue.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/MultiLockFairBlockingQueue.java new file mode 100644 index 0000000..a4b1f73 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/MultiLockFairBlockingQueue.java @@ -0,0 +1,584 @@ +/*- + * ============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(); + } + } + + } + + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolConfiguration.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolConfiguration.java new file mode 100644 index 0000000..42cf11d --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolConfiguration.java @@ -0,0 +1,917 @@ +/*- + * ============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(); + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolExhaustedException.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolExhaustedException.java new file mode 100644 index 0000000..9352581 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolExhaustedException.java @@ -0,0 +1,76 @@ +/*- + * ============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); + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolProperties.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolProperties.java new file mode 100644 index 0000000..9d64c26 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolProperties.java @@ -0,0 +1,1332 @@ +/*- + * ============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(); + } + + + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolUtilities.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolUtilities.java new file mode 100644 index 0000000..cd0d3b2 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PoolUtilities.java @@ -0,0 +1,58 @@ +/*- + * ============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; + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PooledConnection.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PooledConnection.java new file mode 100644 index 0000000..b704c7f --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/PooledConnection.java @@ -0,0 +1,795 @@ +/*- + * ============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; + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/ProxyConnection.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/ProxyConnection.java new file mode 100644 index 0000000..0a67e8e --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/ProxyConnection.java @@ -0,0 +1,176 @@ +/*- + * ============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")+"]"; + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/TrapException.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/TrapException.java new file mode 100644 index 0000000..5c597f3 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/TrapException.java @@ -0,0 +1,101 @@ +/*- + * ============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 + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/Validator.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/Validator.java new file mode 100644 index 0000000..70cef5a --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/Validator.java @@ -0,0 +1,57 @@ +/*- + * ============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); +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/XADataSource.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/XADataSource.java new file mode 100644 index 0000000..4bdb198 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/XADataSource.java @@ -0,0 +1,57 @@ +/*- + * ============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); + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/AbstractCreateStatementInterceptor.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/AbstractCreateStatementInterceptor.java new file mode 100644 index 0000000..e2f1414 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/AbstractCreateStatementInterceptor.java @@ -0,0 +1,158 @@ +/*- + * ============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 + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/AbstractQueryReport.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/AbstractQueryReport.java new file mode 100644 index 0000000..374969d --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/AbstractQueryReport.java @@ -0,0 +1,285 @@ +/*- + * ============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; + } + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/ConnectionState.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/ConnectionState.java new file mode 100644 index 0000000..95049c6 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/ConnectionState.java @@ -0,0 +1,184 @@ +/*- + * ============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; + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/QueryTimeoutInterceptor.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/QueryTimeoutInterceptor.java new file mode 100644 index 0000000..7aec0b4 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/QueryTimeoutInterceptor.java @@ -0,0 +1,77 @@ +/*- + * ============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() { + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/ResetAbandonedTimer.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/ResetAbandonedTimer.java new file mode 100644 index 0000000..6c6981e --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/ResetAbandonedTimer.java @@ -0,0 +1,112 @@ +/*- + * ============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); + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/SlowQueryReport.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/SlowQueryReport.java new file mode 100644 index 0000000..23fa3fa --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/SlowQueryReport.java @@ -0,0 +1,516 @@ +/*- + * ============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; + } + + } + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/SlowQueryReportJmx.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/SlowQueryReportJmx.java new file mode 100644 index 0000000..60b48a0 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/SlowQueryReportJmx.java @@ -0,0 +1,338 @@ +/*- + * ============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())); + } + } + + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/SlowQueryReportJmxMBean.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/SlowQueryReportJmxMBean.java new file mode 100644 index 0000000..202d06e --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/SlowQueryReportJmxMBean.java @@ -0,0 +1,43 @@ +/*- + * ============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; +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/StatementCache.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/StatementCache.java new file mode 100644 index 0000000..e98d3b6 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/StatementCache.java @@ -0,0 +1,358 @@ +/*- + * ============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; + } + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/StatementDecoratorInterceptor.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/StatementDecoratorInterceptor.java new file mode 100644 index 0000000..e3b160b --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/StatementDecoratorInterceptor.java @@ -0,0 +1,342 @@ +/*- + * ============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; + } + } + } + } + } +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/StatementFinalizer.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/StatementFinalizer.java new file mode 100644 index 0000000..6535139 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/StatementFinalizer.java @@ -0,0 +1,136 @@ +/*- + * ============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; + } + } + + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/mbeans-descriptors.xml b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/mbeans-descriptors.xml new file mode 100644 index 0000000..0cca7ad --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/interceptor/mbeans-descriptors.xml @@ -0,0 +1,56 @@ +<?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> diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/jmx/ConnectionPool.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/jmx/ConnectionPool.java new file mode 100644 index 0000000..9044bae --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/jmx/ConnectionPool.java @@ -0,0 +1,960 @@ +/*- + * ============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(); + + } + + + + + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/jmx/ConnectionPoolMBean.java b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/jmx/ConnectionPoolMBean.java new file mode 100644 index 0000000..bc3bbca --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/jmx/ConnectionPoolMBean.java @@ -0,0 +1,107 @@ +/*- + * ============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 + //================================================================= + + +} diff --git a/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/mbeans-descriptors.xml b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/mbeans-descriptors.xml new file mode 100644 index 0000000..591c1d1 --- /dev/null +++ b/dblib/common/src/main/java/org/apache/tomcat/jdbc/pool/mbeans-descriptors.xml @@ -0,0 +1,420 @@ +<?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> diff --git a/dblib/common/src/main/java/org/openecomp/sdnc/sli/resource/common/CommonActivator.java b/dblib/common/src/main/java/org/openecomp/sdnc/sli/resource/common/CommonActivator.java new file mode 100644 index 0000000..6a0ed06 --- /dev/null +++ b/dblib/common/src/main/java/org/openecomp/sdnc/sli/resource/common/CommonActivator.java @@ -0,0 +1,40 @@ +/*- + * ============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 + + } + +} diff --git a/dblib/features/src/main/resources/features.xml b/dblib/features/src/main/resources/features.xml index cc080aa..d7f0030 100755 --- a/dblib/features/src/main/resources/features.xml +++ b/dblib/features/src/main/resources/features.xml @@ -10,6 +10,7 @@ <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.openecomp.sdnc.core/dblib-provider/${project.version}</bundle> <bundle>mvn:mysql/mysql-connector-java/${mysql.connector.version}</bundle> </feature> diff --git a/dblib/pom.xml b/dblib/pom.xml index 0534e07..5adb663 100755 --- a/dblib/pom.xml +++ b/dblib/pom.xml @@ -119,6 +119,7 @@ <name>AT&T</name> </organization> <modules> + <module>common</module> <module>provider</module> <module>features</module> <module>installer</module> diff --git a/dblib/provider/pom.xml b/dblib/provider/pom.xml index 71de996..913adf3 100755 --- a/dblib/provider/pom.xml +++ b/dblib/provider/pom.xml @@ -47,6 +47,11 @@ <artifactId>mysql-connector-java</artifactId> <version>${mysql.connector.version}</version> </dependency> + <dependency> + <groupId>org.openecomp.sdnc.core</groupId> + <artifactId>dblib-common</artifactId> + <version>${project.version}</version> + </dependency> </dependencies> <build> @@ -61,7 +66,10 @@ <Bundle-SymbolicName>org.openecomp.sdnc.sli.resource.dblib</Bundle-SymbolicName> <Bundle-Activator>org.openecomp.sdnc.sli.resource.dblib.DBLIBResourceActivator</Bundle-Activator> <Export-Package>org.openecomp.sdnc.sli.resource.dblib;version=${project.version}</Export-Package> - <Import-Package>org.openecomp.sdnc.sli.*,org.osgi.framework.*,org.slf4j.*,com.mysql.jdbc.*,javax.sql.*</Import-Package> + <!-- + <Import-Package>org.openecomp.sdnc.sli.*,org.osgi.framework.*,org.slf4j.*,com.mysql.jdbc.*,javax.sql.*,org.apache.tomcat.*</Import-Package> + --> + <Import-Package>*</Import-Package> <Embed-Transitive>true</Embed-Transitive> </instructions> </configuration> diff --git a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/CachedDataSourceFactory.java b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/CachedDataSourceFactory.java index f774748..3e51ed9 100644 --- a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/CachedDataSourceFactory.java +++ b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/CachedDataSourceFactory.java @@ -23,9 +23,8 @@ package org.openecomp.sdnc.sli.resource.dblib; import org.openecomp.sdnc.sli.resource.dblib.config.BaseDBConfiguration; import org.openecomp.sdnc.sli.resource.dblib.config.JDBCConfiguration; -import org.openecomp.sdnc.sli.resource.dblib.config.JndiConfiguration; +import org.openecomp.sdnc.sli.resource.dblib.jdbc.JdbcDBCachedDataSource; import org.openecomp.sdnc.sli.resource.dblib.jdbc.MySQLCachedDataSource; -import org.openecomp.sdnc.sli.resource.dblib.jndi.JndiCachedDataSource; /** * @version $Revision: 1.1 $ @@ -38,9 +37,8 @@ public class CachedDataSourceFactory { public static CachedDataSource createDataSource(BaseDBConfiguration config) { if(config instanceof JDBCConfiguration) - return MySQLCachedDataSource.createInstance(config); - if(config instanceof JndiConfiguration) - return JndiCachedDataSource.createInstance(config); + return JdbcDBCachedDataSource.createInstance(config); + return (CachedDataSource)null; } diff --git a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/DBResourceManager.java b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/DBResourceManager.java index 7f85c42..401c013 100644 --- a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/DBResourceManager.java +++ b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/DBResourceManager.java @@ -53,7 +53,6 @@ import org.openecomp.sdnc.sli.resource.dblib.pm.SQLExecutionMonitor; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.sun.rowset.providers.RIOptimisticProvider; /** * @version $Revision: 1.15 $ @@ -87,7 +86,7 @@ public class DBResourceManager implements DataSource, DataAccessor, DBResourceOb } return 0; } - + }); protected final Set<CachedDataSource> broken = Collections.synchronizedSet(new HashSet<CachedDataSource>()); protected final Object monitor = new Object(); @@ -131,17 +130,6 @@ public class DBResourceManager implements DataSource, DataAccessor, DBResourceOb worker.setName("DBResourcemanagerWatchThread"); worker.setDaemon(true); worker.start(); - - try { - RIOptimisticProvider rio = new RIOptimisticProvider(); - LOGGER.info("Class " + rio.getClass().getName() + " found."); - Class clas = this.getClass().getClassLoader().loadClass("com.sun.rowset.providers.RIOptimisticProvider"); - if(clas != null) { - LOGGER.info("Class " + rio.getClass().getName() + " found by classloader."); - } - } catch(Exception exc) { - LOGGER.info("Failed resolving RIOptimisticProvider class", exc); - } } private void config(Properties ctx) throws Exception { @@ -320,7 +308,7 @@ public class DBResourceManager implements DataSource, DataAccessor, DBResourceOb Collections.reverse(sources); } - + // loop through available data sources to retrieve data. while(!sources.isEmpty()) { @@ -428,7 +416,7 @@ public class DBResourceManager implements DataSource, DataAccessor, DBResourceOb public boolean writeData(String statement, ArrayList<String> arguments, String preferredDS) throws SQLException { return writeDataNoRecovery(statement, arguments, preferredDS); } - + CachedDataSource findMaster() { CachedDataSource master = null; CachedDataSource[] dss = this.dsQueue.toArray(new CachedDataSource[0]); @@ -468,7 +456,7 @@ public class DBResourceManager implements DataSource, DataAccessor, DBResourceOb active = master; } } - + return active.writeData(statement, arguments); } catch(Throwable exc){ String message = exc.getMessage(); diff --git a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/config/DbConfigPool.java b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/config/DbConfigPool.java index 90ea6bc..117f932 100644 --- a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/config/DbConfigPool.java +++ b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/config/DbConfigPool.java @@ -46,10 +46,6 @@ public class DbConfigPool { return type; } - public JndiConfiguration[] getJndiDbSourceArray() { - return configurations.toArray(new JndiConfiguration[configurations.size()]); - } - public JDBCConfiguration[] getJDBCbSourceArray() { return configurations.toArray(new JDBCConfiguration[configurations.size()]); } diff --git a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/AbstractDBResourceManagerFactory.java b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/AbstractDBResourceManagerFactory.java index e6b1a35..f4291a7 100644 --- a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/AbstractDBResourceManagerFactory.java +++ b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/AbstractDBResourceManagerFactory.java @@ -21,7 +21,6 @@ package org.openecomp.sdnc.sli.resource.dblib.factory; import org.openecomp.sdnc.sli.resource.dblib.jdbc.JdbcDbResourceManagerFactory; -import org.openecomp.sdnc.sli.resource.dblib.jndi.JNDIDbResourceManagerFactory; /** * @version $Revision: 1.1 $ @@ -33,13 +32,7 @@ import org.openecomp.sdnc.sli.resource.dblib.jndi.JNDIDbResourceManagerFactory; public class AbstractDBResourceManagerFactory { public static AbstractResourceManagerFactory getFactory(String type) throws FactoryNotDefinedException { - - if("JNDI".equals(type)){ - try { - return JNDIDbResourceManagerFactory.createIntstance(); - } catch (Exception e) { - } - } + // JDBC return JdbcDbResourceManagerFactory.createIntstance(); } diff --git a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/AbstractResourceManagerFactory.java b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/AbstractResourceManagerFactory.java index 148ddac..29ec061 100644 --- a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/AbstractResourceManagerFactory.java +++ b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/AbstractResourceManagerFactory.java @@ -32,7 +32,6 @@ import org.openecomp.sdnc.sli.resource.dblib.DBResourceManager; import org.openecomp.sdnc.sli.resource.dblib.config.BaseDBConfiguration; import org.openecomp.sdnc.sli.resource.dblib.config.DbConfigPool; import org.openecomp.sdnc.sli.resource.dblib.config.JDBCConfiguration; -import org.openecomp.sdnc.sli.resource.dblib.config.JndiConfiguration; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -49,20 +48,15 @@ public abstract class AbstractResourceManagerFactory { public abstract CachedDataSource[] initDBResourceManager(DbConfigPool dbConfig, DBResourceManager manager) throws Exception; public abstract CachedDataSource[] initDBResourceManager(DbConfigPool dbConfig, DBResourceManager dbResourceManager, String sourceName) throws SQLException ; - + public static AbstractResourceManagerFactory createIntstance() throws FactoryNotDefinedException { throw new FactoryNotDefinedException("Factory method 'createIntstance' needs to be overriden in DBResourceManagerFactory"); } - public class DBInitTask implements Callable<CachedDataSource> + public class DBInitTask implements Callable<CachedDataSource> { private BaseDBConfiguration config = null; private Set<DBInitTask> activeTasks; - - public DBInitTask(JndiConfiguration jndiConfig, Set<DBInitTask> tasks){ - this.config = jndiConfig; - this.activeTasks = tasks; - } public DBInitTask(JDBCConfiguration jdbcconfig, Set<DBInitTask> tasks) { this.config = jdbcconfig; @@ -97,6 +91,7 @@ public abstract class AbstractResourceManagerFactory { worker.start(); } else { if(LOGGER.isDebugEnabled()) + if(ds != null) LOGGER.debug("Completed CachedDataSource.Call from "+ds.getDbConnectionName()); } } diff --git a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/DBConfigFactory.java b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/DBConfigFactory.java index 7044082..3530459 100644 --- a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/DBConfigFactory.java +++ b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/factory/DBConfigFactory.java @@ -25,10 +25,11 @@ import java.util.ArrayList; import java.util.Iterator; import java.util.Properties; +import org.slf4j.LoggerFactory; + import org.openecomp.sdnc.sli.resource.dblib.config.BaseDBConfiguration; import org.openecomp.sdnc.sli.resource.dblib.config.DbConfigPool; import org.openecomp.sdnc.sli.resource.dblib.config.JDBCConfiguration; -import org.openecomp.sdnc.sli.resource.dblib.config.JndiConfiguration; /** * @version $Revision: 1.1 $ @@ -44,7 +45,7 @@ public class DBConfigFactory { } static DbConfigPool getConfigparams(Properties properties){ - org.slf4j.LoggerFactory.getLogger(DBConfigFactory.class).info(properties.toString()); + LoggerFactory.getLogger(DBConfigFactory.class).info(properties.toString()); DbConfigPool xmlConfig = new DbConfigPool(properties); ArrayList<Properties> propertySets = new ArrayList<Properties>(); @@ -78,7 +79,7 @@ public class DBConfigFactory { } } catch (Exception e) { - org.slf4j.LoggerFactory.getLogger(DBConfigFactory.class).warn("",e); + LoggerFactory.getLogger(DBConfigFactory.class).warn("",e); } return xmlConfig; @@ -89,15 +90,12 @@ public class DBConfigFactory { String type = props.getProperty(BaseDBConfiguration.DATABASE_TYPE); BaseDBConfiguration config = null; - - if("JNDI".equalsIgnoreCase(type)) { - config = new JndiConfiguration(props); - } + if("JDBC".equalsIgnoreCase(type)) { config = new JDBCConfiguration(props); } return config; - + } } diff --git a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/jdbc/JdbcDBCachedDataSource.java b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/jdbc/JdbcDBCachedDataSource.java new file mode 100644 index 0000000..ee3d4ff --- /dev/null +++ b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/jdbc/JdbcDBCachedDataSource.java @@ -0,0 +1,252 @@ +/*- + * ============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.dblib.jdbc; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLFeatureNotSupportedException; + +import org.apache.tomcat.jdbc.pool.DataSource; +import org.apache.tomcat.jdbc.pool.PoolProperties; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.openecomp.sdnc.sli.resource.dblib.CachedDataSource; +import org.openecomp.sdnc.sli.resource.dblib.DBConfigException; +import org.openecomp.sdnc.sli.resource.dblib.config.BaseDBConfiguration; +import org.openecomp.sdnc.sli.resource.dblib.config.JDBCConfiguration; +import com.mysql.jdbc.Driver; + + +/** + * @version $Revision: 1.7 $ + * Change Log + * Author Date Comments + * ============== ======== ==================================================== + * Rich Tabedzki + */ + +public class JdbcDBCachedDataSource extends CachedDataSource +{ + private String dbUserId; + private String dbPasswd; + private String dbUrl; + + private int minLimit; + private int maxLimit; + private int initialLimit; + + private static final String AS_CONF_ERROR = "AS_CONF_ERROR: "; + + private static Logger LOGGER = LoggerFactory.getLogger(JdbcDBCachedDataSource.class); + + /** + * @param jdbcElem + * @param alarmLog + * @param occManager + * @throws Exception + */ + public JdbcDBCachedDataSource(BaseDBConfiguration jdbcElem) + { + super(jdbcElem); + } + + @Override + protected void configure(BaseDBConfiguration xmlElem) throws DBConfigException + { + BaseDBConfiguration jdbcConfig = (BaseDBConfiguration)xmlElem; + if(jdbcConfig.getConnTimeout() > 0){ + this.CONN_REQ_TIMEOUT = jdbcConfig.getConnTimeout(); + } + if(jdbcConfig.getRequestTimeout() > 0){ + this.DATA_REQ_TIMEOUT = jdbcConfig.getRequestTimeout(); + } + + // set connection pool name + String dbConnectionName = jdbcConfig.getDbConnectionName(); + super.setDbConnectionName(dbConnectionName); + // Configure the JDBC connection + dbUserId = jdbcConfig.getDbUserId(); + if (dbUserId == null) + { + String errorMsg = "Invalid XML contents: JDBCConnection missing dbUserId attribute"; + LOGGER.error(AS_CONF_ERROR + errorMsg); + throw new DBConfigException(errorMsg); + } + + dbPasswd = jdbcConfig.getDbPasswd(); + if (dbPasswd == null) + { + String errorMsg = "Invalid XML contents: JDBCConnection missing dbPasswd attribute"; + LOGGER.error(AS_CONF_ERROR + errorMsg); + throw new DBConfigException(errorMsg); + } + /* + dbDriver = jdbcConfig.getDbDriver(); + if (dbDriver == null) + { + String errorMsg = "Invalid XML contents: JDBCConnection missing dbDriver attribute"; + LOGGER.error(AS_CONF_ERROR + errorMsg); + throw new ScpTblUpdateError(errorMsg); + } + */ + + minLimit = jdbcConfig.getDbMinLimit(); +// if (minLimit == null) +// { +// String errorMsg = "Invalid XML contents: JDBC Connection missing minLimit attribute"; +// LOGGER.error(AS_CONF_ERROR + errorMsg); +// throw new DBConfigException(errorMsg); +// } + maxLimit = jdbcConfig.getDbMaxLimit(); +// if (maxLimit == null) +// { +// String errorMsg = "Invalid XML contents: JDBC Connection missing maxLimit attribute"; +// LOGGER.error(AS_CONF_ERROR + errorMsg); +// throw new DBConfigException(errorMsg); +// } + initialLimit = jdbcConfig.getDbInitialLimit(); +// if (initialLimit == null) +// { +// String errorMsg = "Invalid XML contents: JDBC Connection missing initialLimit attribute"; +// LOGGER.error(AS_CONF_ERROR + errorMsg); +// throw new DBConfigException(errorMsg); +// } + + dbUrl = jdbcConfig.getDbUrl(); + if(dbUrl == null){ + String errorMsg = "Invalid XML contents: JDBCConnection missing dbUrl attribute"; + LOGGER.error(AS_CONF_ERROR + errorMsg); + throw new DBConfigException(errorMsg); + } + + try { + Driver dr = new com.mysql.jdbc.Driver(); + Class clazz = Class.forName("com.mysql.jdbc.Driver") ; + + PoolProperties p = new PoolProperties(); + p.setDriverClassName("com.mysql.jdbc.Driver"); + p.setUrl(dbUrl); + p.setUsername(dbUserId); + p.setPassword(dbPasswd); + p.setJmxEnabled(true); + p.setTestWhileIdle(false); + p.setTestOnBorrow(true); + p.setValidationQuery("SELECT 1"); + p.setTestOnReturn(false); + p.setValidationInterval(30000); + p.setTimeBetweenEvictionRunsMillis(30000); + p.setInitialSize(initialLimit); + p.setMaxActive(maxLimit); + p.setMaxIdle(maxLimit); + p.setMaxWait(10000); + p.setRemoveAbandonedTimeout(60); + p.setMinEvictableIdleTimeMillis(30000); + p.setMinIdle(minLimit); + 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(p); + + synchronized(this) + { + this.ds = dataSource; + Connection con = null; + PreparedStatement st = null; + ResultSet rs = null; + + try { + con = dataSource.getConnection(); + st = con.prepareStatement("Select 1 FROM DUAL"); + rs = st.executeQuery(); + } catch(Exception exc) { + LOGGER.error(exc.getMessage()); + } finally { + if(rs != null) rs.close(); + if(st != null) st.close(); + if(con != null) con.close(); + } + + initialized = true; + LOGGER.info("MySQLDataSource <"+dbConnectionName+"> configured successfully. Using URL: "+dbUrl); + } + +// } catch (SQLException exc) { +// initialized = false; +// StringBuffer sb = new StringBuffer(); +// sb.append("Failed to initialize MySQLDataSource<"); +// sb.append(dbConnectionName).append(">. Reason: "); +// sb.append(exc.getMessage()); +// LOGGER.error("AS_CONF_ERROR: " + sb.toString()); +//// throw new DBConfigException(e.getMessage()); + } catch (Exception exc) { + initialized = false; + StringBuffer sb = new StringBuffer(); + sb.append("Failed to initialize MySQLCachedDataSource <"); + sb.append(dbConnectionName).append(">. Reason: "); + sb.append(exc.getMessage()); + LOGGER.error("AS_CONF_ERROR: " + sb.toString()); +// throw new DBConfigException(e.getMessage()); + } + } + + public final String getDbUrl() + { + return dbUrl; + } + + public final String getDbUserId() + { + return dbUserId; + } + + public final String getDbPasswd() + { + return dbPasswd; + } + + public static JdbcDBCachedDataSource createInstance(BaseDBConfiguration config) /*throws Exception*/ { + return new JdbcDBCachedDataSource(config); + } + + public String toString(){ + return getDbConnectionName(); + } + + public java.util.logging.Logger getParentLogger() + throws SQLFeatureNotSupportedException { + // TODO Auto-generated method stub + return null; + } + + public void cleanUp(){ + DataSource dataSource = (DataSource)ds; + dataSource.getPool().purge(); + int active = dataSource.getActive(); + int size = dataSource.getSize(); + dataSource.close(true); + super.cleanUp(); + } + +} diff --git a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/jndi/JNDIDbResourceManagerFactory.java b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/jndi/JNDIDbResourceManagerFactory.java deleted file mode 100644 index 2888bc5..0000000 --- a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/jndi/JNDIDbResourceManagerFactory.java +++ /dev/null @@ -1,167 +0,0 @@ -/*- - * ============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.dblib.jndi; - -import java.sql.SQLException; -import java.util.HashSet; -import java.util.Set; -import java.util.concurrent.Callable; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.FutureTask; - -import org.openecomp.sdnc.sli.resource.dblib.CachedDataSource; -import org.openecomp.sdnc.sli.resource.dblib.CachedDataSourceFactory; -import org.openecomp.sdnc.sli.resource.dblib.DBResourceManager; -import org.openecomp.sdnc.sli.resource.dblib.config.DbConfigPool; -import org.openecomp.sdnc.sli.resource.dblib.config.JndiConfiguration; -import org.openecomp.sdnc.sli.resource.dblib.factory.AbstractResourceManagerFactory; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -/** - * @version $Revision: 1.6 $ - * Change Log - * Author Date Comments - * ============== ======== ==================================================== - * Rich Tabedzki - */ -public class JNDIDbResourceManagerFactory extends AbstractResourceManagerFactory { - - private static Logger LOGGER = LoggerFactory.getLogger(JNDIDbResourceManagerFactory.class); - - class MyFutureTask extends FutureTask<DBInitTask> - { - - public MyFutureTask(Callable<CachedDataSource> result) { - super((Callable)result); - } - - } - - public CachedDataSource[] initDBResourceManager(DbConfigPool dbConfig, DBResourceManager manager, String sourceName) throws SQLException - { - // here create the data sources objects - JndiConfiguration[] list = dbConfig.getJndiDbSourceArray(); - CachedDataSource[] cachedDS = new CachedDataSource[1]; - - for(int i=0, max=list.length; i<max; i++){ - if(!sourceName.equals(list[i].getJndiConnectionName())) - continue; - - JndiConfiguration config = list[i]; - CachedDataSource dataSource = CachedDataSourceFactory.createDataSource(config); - cachedDS[0] = dataSource; - } - return cachedDS; - } - - public CachedDataSource[] initDBResourceManager(DbConfigPool dbConfig, DBResourceManager manager) /* throws Exception */ { -// WSConfigManagement ws = WSConfigManagement.getInstance(); - - ExecutorService threadExecutor = Executors.newFixedThreadPool(2); - // here create the data sources objects - JndiConfiguration[] list = dbConfig.getJndiDbSourceArray(); - FutureTask<DBInitTask>[] futures = new MyFutureTask[list.length]; - final Set<DBInitTask> tasks = new HashSet<DBInitTask>(); - if(LOGGER.isDebugEnabled()) - LOGGER.debug("Creating datasources."); - for(int i=0, max=list.length; i<max; i++){ - JndiConfiguration config = list[i]; -// if(manager.getJndiContextFactoryStr()!=null && manager.getJndiContextFactoryStr().trim().length()>0){ -// config.setJndiContextFactory(manager.getJndiContextFactoryStr()); -// } -// if(manager.getJndiURLStr()!=null && manager.getJndiURLStr().trim().length()>0){ -// config.setJndiURL(manager.getJndiURLStr()); -// } - DBInitTask task = new DBInitTask(config, tasks); - tasks.add(task); - futures[i] = new MyFutureTask(task); - } - - try { - synchronized(tasks){ - for(int i=0, max=list.length; i<max; i++){ - threadExecutor.execute(futures[i]); - } - // the timeout param is set is seconds. - long timeout = ((dbConfig.getTimeout() <= 0) ? 60L : dbConfig.getTimeout()); - timeout *= 1000; - // the timeout param is set is seconds, hence it needs to be multiplied by 1000. - tasks.wait(timeout); - if(LOGGER.isDebugEnabled()) - LOGGER.debug("initDBResourceManager wait completed."); - } - } catch(Exception exc) { - LOGGER.error("Failed to initialize JndiCachedDataSource. Reason: ", exc); - } - - if(threadExecutor != null){ - try { - threadExecutor.shutdown(); - } catch(Exception exc){} - } - - CachedDataSource[] cachedDS = new CachedDataSource[futures.length]; - - boolean initialized = false; - for(int i=0; i<futures.length; i++){ - Object obj = null; - if(futures[i].isDone()){ - try { - obj = futures[i].get(); - if(obj instanceof CachedDataSource){ - cachedDS[i] = (CachedDataSource)obj; - initialized = true; - LOGGER.info("DataSource "+list[i].getJndiConnectionName()+" initialized successfully"); - } - } catch (InterruptedException exc) { - LOGGER.error("DataSource "+list[i].getJndiConnectionName()+" initialization failed", exc); - } catch (ExecutionException exc) { - LOGGER.error("DataSource "+list[i].getJndiConnectionName()+" initialization failed", exc); - } catch (Exception exc) { - LOGGER.error("DataSource "+list[i].getJndiConnectionName()+" initialization failed", exc); - } - } else { - try { - obj = futures[i].get(); - if(obj instanceof CachedDataSource){ - - LOGGER.error("DataSource "+((CachedDataSource)obj).getDbConnectionName()+" failed"); - } - } catch (Exception exc) { - LOGGER.error("DataSource "+list[i].getJndiConnectionName()+" initialization failed", exc); - } - } - } - - if(!initialized){ - new Error("Failed to initialize DB Library."); - } - return cachedDS; - } - - public static AbstractResourceManagerFactory createIntstance() { - return new JNDIDbResourceManagerFactory(); - } - -} diff --git a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/jndi/JndiCachedDataSource.java b/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/jndi/JndiCachedDataSource.java deleted file mode 100644 index 19fa8e9..0000000 --- a/dblib/provider/src/main/java/org/openecomp/sdnc/sli/resource/dblib/jndi/JndiCachedDataSource.java +++ /dev/null @@ -1,131 +0,0 @@ -/*- - * ============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.dblib.jndi; - -import java.sql.SQLFeatureNotSupportedException; -import java.util.Properties; - -import javax.naming.Context; -import javax.naming.InitialContext; -import javax.naming.NamingException; - -import org.openecomp.sdnc.sli.resource.dblib.CachedDataSource; -import org.openecomp.sdnc.sli.resource.dblib.DBConfigException; -import org.openecomp.sdnc.sli.resource.dblib.config.BaseDBConfiguration; -import org.openecomp.sdnc.sli.resource.dblib.config.JndiConfiguration; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.xml.sax.SAXException; - -/** - * @version $Revision: 1.2 $ - * Change Log - * Author Date Comments - * ============== ======== ==================================================== - * Rich Tabedzki - */ -public class JndiCachedDataSource extends CachedDataSource -{ - private static Logger LOGGER = LoggerFactory.getLogger(JndiCachedDataSource.class); - /** - * @param alarmLog - * @param jdbcElem - * @throws SAXException - * @throws ScpTblUpdateError - */ - public JndiCachedDataSource(BaseDBConfiguration xmlElem) throws DBConfigException - { - super(xmlElem); - } - - protected void configure(BaseDBConfiguration xmlElem) throws DBConfigException { - JndiConfiguration jdbcConfig = (JndiConfiguration)xmlElem; - String jndiContextFactoryStr = jdbcConfig.getJndiContextFactory(); - String jndiURLStr = jdbcConfig.getJndiURL(); - String jndiSourceStr = jdbcConfig.getJndiSource(); - - if(jdbcConfig.getConnTimeout() > 0){ - this.CONN_REQ_TIMEOUT = jdbcConfig.getConnTimeout(); - } - if(jdbcConfig.getRequestTimeout() > 0){ - this.DATA_REQ_TIMEOUT = jdbcConfig.getRequestTimeout(); - } - - super.setDbConnectionName(jdbcConfig.getJndiConnectionName()); - - if(jndiContextFactoryStr == null || jndiContextFactoryStr.length() == 0) - { -// throw new DBConfigException("The jndi configuration is incomplete: jndiContextFactory"); - } - if(jndiURLStr == null || jndiContextFactoryStr.length() == 0) - { -// throw new ScpTblUpdateError("The jndi configuration is incomplete: jndiURL"); - } - if(jndiSourceStr == null || jndiSourceStr.length() == 0) - { - throw new DBConfigException("The jndi configuration is incomplete: jndiSource"); - } - - Properties env = new Properties(); - Context ctx; - try - { - if(jndiContextFactoryStr != null && jndiContextFactoryStr.length() != 0){ - env.put(Context.INITIAL_CONTEXT_FACTORY, jndiContextFactoryStr); - ctx = new InitialContext(env); - } else { - ctx = new InitialContext(); - } - ds = (javax.sql.DataSource) ctx.lookup (jndiSourceStr); - if(ds == null) - { - this.initialized = false; - LOGGER.error("AS_CONF_ERROR: Failed to initialize DataSource <"+getDbConnectionName()+"> using JNDI <"+jndiSourceStr+">"); - return; - } else { - this.initialized = true; - LOGGER.info("JndiCachedDataSource <"+getDbConnectionName()+"> configured successfully."); - return; - } - } catch (NamingException exc) { - this.initialized = false; - LOGGER.error("AS_CONF_ERROR" + exc.getMessage()); - - } catch(Throwable exc) { - this.initialized = false; - LOGGER.error("AS_CONF_ERROR: " + exc.getMessage()); - } - } - - public static JndiCachedDataSource createInstance(BaseDBConfiguration config) { - return new JndiCachedDataSource(config); - } - - public String toString(){ - return getDbConnectionName(); - } - - public java.util.logging.Logger getParentLogger() - throws SQLFeatureNotSupportedException { - // TODO Auto-generated method stub - return null; - } -} diff --git a/dblib/provider/src/main/resources/dblib.properties b/dblib/provider/src/main/resources/dblib.properties index 3872288..0f28f1f 100755 --- a/dblib/provider/src/main/resources/dblib.properties +++ b/dblib/provider/src/main/resources/dblib.properties @@ -3,7 +3,7 @@ org.openecomp.sdnc.sli.jdbc.hosts=sdnctldb01,sdnctldb02 org.openecomp.sdnc.sli.jdbc.url=jdbc:mysql://DBHOST:3306/sdnctl org.openecomp.sdnc.sli.jdbc.database=sdnctl org.openecomp.sdnc.sli.jdbc.user=sdnctl -org.openecomp.sdnc.sli.jdbc.password=gamma +org.openecomp.sdnc.sli.jdbc.password={password for sdnctl} org.openecomp.sdnc.sli.jdbc.connection.name=sdnctldb01 org.openecomp.sdnc.sli.jdbc.connection.timeout=50 |