pax_global_header 0000666 0000000 0000000 00000000064 13154316420 0014511 g ustar 00root root 0000000 0000000 52 comment=ec8510710ac71f79f513c19f35d5da320c92e2f2
HikariCP-HikariCP-2.7.1/ 0000775 0000000 0000000 00000000000 13154316420 0014602 5 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/.editorconfig 0000664 0000000 0000000 00000000427 13154316420 0017262 0 ustar 00root root 0000000 0000000 # EditorConfig is awesome: http://EditorConfig.org
# top-most EditorConfig file
root = true
[**]
end_of_line = lf
insert_final_newline = true
charset = utf-8
indent_style = space
trim_trailing_whitespace = true
[**.{java,xml}]
indent_size = 3
[**.{yaml,yml}]
indent_size = 2
HikariCP-HikariCP-2.7.1/.github/ 0000775 0000000 0000000 00000000000 13154316420 0016142 5 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/.github/ISSUE_TEMPLATE.md 0000664 0000000 0000000 00000000346 13154316420 0020652 0 ustar 00root root 0000000 0000000 #### Environment
```
HikariCP version: x.x.x
JDK version : 1.8.0_111
Database : PostgreSQL|MySQL|...
Driver version : x.x.x
```
-----------------------------------------------------------------------------------------
HikariCP-HikariCP-2.7.1/.gitignore 0000664 0000000 0000000 00000000300 13154316420 0016563 0 ustar 00root root 0000000 0000000 .classpath
.project
.settings/
target/
dependency-reduced-pom.xml
.DS_Store
**/*.iml
*.class
*.jar
*.war
*.ear
*.iml
*.iws
*.ipr
.tm_*
.classpath
.project
.settings/
.idea/
.gradle/
out/
HikariCP-HikariCP-2.7.1/.travis.yml 0000664 0000000 0000000 00000001436 13154316420 0016717 0 ustar 00root root 0000000 0000000 sudo: false
language: java
dist:
- trusty
before_script:
- if [[ "x$JDK" == *'x9'* ]]; then export MAVEN_SKIP_RC=true; fi
- if [[ "x$JDK" != *'x9'* ]]; then export COVERALLS=coveralls:report; fi
script:
- export JDK8_HOME=$(jdk_switcher home oraclejdk8)
- export JDK9_HOME=/usr/lib/jvm/java-9-oracle
- test -d "${JDK9_HOME}" || export JDK9_HOME=$(jdk_switcher home oraclejdk8)
before_cache:
# No sense in caching current build artifacts
- rm -rf $HOME/.m2/repository/com/zaxxer
cache:
directories:
- $HOME/.m2/repository
matrix:
fast_finish: true
include:
- jdk: oraclejdk8
- jdk: oraclejdk9
env:
- JDK=9
install: /bin/true
script:
- mvn package -Dskip.unit.tests=true -Dmaven.javadoc.skip=true -V -B
- mvn test $COVERALLS -V -P coverage
HikariCP-HikariCP-2.7.1/CHANGES 0000664 0000000 0000000 00000073104 13154316420 0015602 0 ustar 00root root 0000000 0000000 HikariCP Changes
Changes in 2.7.1
* issue 968 Wrong label order in MicrometerMetricsTracker for the connection usage
metric.
* issue 967 incorrect bitwise operator value in ConcurrentBag.requite method
intended to cause parkNanos() to be called every 256 iterations. Thanks to @ztkmkoo
for finding this.
Changes in 2.7.0
* added support for micrometer metrics (currently Alpha-level support).
* issue 905 mask JDBC password in URLs
* issue 940 fix Prometheus metric collector for multiple data config
* issue 941 add support for setting a default schema
* issue 955 fix possible race condition when Statements are closed on different
threads from which they were created.
Changes in 2.6.3
* issue 878 load driver class from ThreadContext classloader if it is not found
via the regular classloader.
Changes in 2.6.2
* issue 890 add support for Prometheus metrics and multiple HikariCP pools.
* issue 880 fix race condition caused by sorting collection while the condition of
sort can change.
* issue 876 add support for using a Prometheus CollectorRegistry other than the
default one.
* issue 867 support network timeout even for Connection.isValid().
* issue 866 mark commit state dirty when Connection.getMetaData() is called.
Changes in 2.6.1
* issue 821 if a disconnection class exception is thrown during initial connection
setup, do not set the flag that indicates that checkDriverSupport() is complete.
* issue 835 fix increased CPU consumption under heavy load caused by excessive
spinning in the ConcurrentBag.requite() method.
* issue 817 updated behavior of new initializationFailTimeout, please see the
official documentation for details.
* issue 742 add direct MXBean accessor methods to HikariDataSource for users who do
not want run run JMX.
Changes in 2.6.0
* Redesign of the contention code path resulting in doubling contended throughput; now
contended pool access retains 98% of the uncontended throughput.
* issue 793 add new HikariConfig method, setScheduledExecutor(ScheduledExecutorService),
and deprecate method setScheduledExecutorService(ScheduledThreadPoolExecutor). It is
unfortunate that the deprecated method has the more accurate name, but its signature
cannot be changed without breaking binary compatibility.
* issue 770 add a new property initializationFailTimeout, and deprecate configuration
property initializationFailFast.
* issue 774 significantly improve spike load handling.
* issues 518/769 add new metric for tracking how long physical connection acquisition is
taking. DropWizard histogram name "ConnectionCreation", and Prometheus summary name
"hikaricp_connection_creation_millis".
* issue 741 cancel HouseKeeper task on pool shutdown. If the ScheduledExecutor being used
did not belong to HikariCP, this task would remain scheduled after shutdown, causing a
memory leak.
* issue 781 more technically accurate wording of pool startup and shutdown log messages.
Changes in 2.5.1
* issue 719 only reset lastConnectionFailure after a successful dataSource.getConnection()
call.
* issue 716 do not scan deeper than 10 nested SQLExceptions, it's typically a trap ...
a chain that never terminates.
* issue 714 fix possible issue with cross-thread visibility. Change pool entry state from
AtomicInteger w/lazySet() to a volatile int with use of AtomicIntegerFieldUpdater.
Changes in 2.5.0
* Release 2.5.0 marks the start of a Java 8 HikariCP artifact. The Java 7 artifact is
now called "HikariCP-java7".
* HikariCP 2.5.0 and HikariCP-java7 2.4.8 have identical functionality.
Changes in 2.4.12
* issue 878 search for driverClass in both HikariCP class classloader and Thread Context
ClassLoader
Changes in 2.4.11
* issue 793 add new HikariConfig method, setScheduledExecutor(ScheduledExecutorService),
and deprecate method setScheduledExecutorService(ScheduledThreadPoolExecutor). It is
unfortunate that the deprecated method has the more accurate name, but its signature
cannot be changed without breaking binary compatibility.
* issue 600 ignore Java 8 default methods when generating proxy classes for Java 7.
Changes in 2.4.10
* Redesign of the contention code path resulting in doubling contended throughput; now
contended pool access retains 98% of the uncontended throughput.
* issue 770 add a new property initializationFailTimeout, and deprecate configuration
property initializationFailFast.
* issue 774 significantly improve spike load handling.
* issue 741 cancel HouseKeeper task on pool shutdown. If the ScheduledExecutor being used
did not belong to HikariCP, this task would remain scheduled after shutdown, causing a
memory leak.
Changes in 2.4.9
* issue 719 only reset lastConnectionFailure after a successful dataSource.getConnection()
call.
* issue 716 do not scan deeper than 10 nested SQLExceptions, it's typically a trap ...
a chain that never terminates.
* issue 714 fix possible issue with cross-thread visibility. Change pool entry state from
AtomicInteger w/lazySet() to a volatile int with use of AtomicIntegerFieldUpdater.
Changes in 2.4.8
* Release 2.4.8 marks the start of a Java 7 HikariCP artifact, HikariCP-java7, representing
support for Java 7 entering maintenance mode.
* Added Connection.commit() call to the fail-fast initialization for databases that
automatically start a new Connection in a transaction and throw an exception on close
if it is not committed.
* feature 694: report if a previously reported leaked connection is returned to the pool
* issue 689: log a warning if default transaction isolation level cannot be detected.
This can occur with pseudo-database drivers such as the one for JSonar
* issue 674: fix regression caused by pull request #450 (overzealous optimisation)
Changes in 2.4.7
* Miscellaneous stability improvements.
* Removed Oracle SQL state 61000, added specific error code (2399) to evict connections
when it is encountered.
* issue 664: do not recycle PoolEntry objects that have closed their held connection.
* issue 641, 643: reflection used method String.toUpperCase() without a Locale, which causes
problems in some locales such as Turkish.
* pull 632: added support for Prometheus metrics tracker.
* issue 650: detect Amazon Redshift connection refused error codes.
Changes in 2.4.6
* Added Oracle SQL error code 61000 (exceeded maximum connect time) to evict connections
when it is encountered.
* issue 621: fix NPE in shutdown if invoked during initialization.
* issue 606, 610: housekeeper thread was running before all class members were
initialized, causing an unrecoverable exception and disabling idle connection
retirement (maximumLifetime still applied).
Changes in 2.4.5
* issue 596: fix bug that occurs when minimumIdle is set to 0, but maximumPoolSize is
not explicitly set.
* issue 594: fix incompatibility with various libraries caused by storing a non-String
object in System properties.
* issue 593: improve logging when network timeout is not supported by the driver
* issue 591: improve thread-safety of Statement proxies
Changes in 2.4.4
* Generate unique sequential pool names, even across container classloaders to avoid
JMX name collisions when registering pools.
* Improve pool stability when running on computers using power-saving or sleep modes
where wake-up previously caused pool to grow to maximum size.
* Improve pool stability under severe thread-starvation conditions. Previous code
could interpret prolonged starvation (exceeding one minute) as non-contiguous clock
advancement, and reacted by soft-evicting connections (unnecessarily).
* Added connection timeout rate to Dropwizard metrics (ConnectionTimeoutRate).
* issue 563: Do not start the house-keeping thread until after pool initialisation
has succeeded.
* issue 559: Ensure the pool refill after house-keeping does not enqueue more add
connection requests if there are already minimumIdle requests pending.
* issue 555: include support for Java 8 interface 'default' methods during proxy
generation.
* issue 547: decreased allowable minimum connectionTimeout and validationTimeout to
250ms.
* issue 495: implemented iterator() method on custom FastList to support Tomcat
memory leak detection.
Changes in 2.3.13
* issue 512: reduce the number of calls made to Connection.getAutoCommit().
Changes in 2.4.3
* Improve pool shutdown behavior. Stop active connection acquisition once the
shutdown sequence has initiated.
* Improved detection and reporting of ambiguous pool configuration, when both the
connection URL and DataSource class names are specified.
Changes in 2.4.2
* Improve accuracy of timeouts for getConnection() calls by accounting for possibly
long delay aliveness tests.
* Improve adherence to minimumIdle goal by closing idle connections starting from
longest idle time to shortest. Additionally, stop when minimumIdle is reached even
if connections exceeding idleTimeout remain (but are still within maxLifetime).
* Introduce larger variance into maxLifetime to avoid mass connection closing and
subsequent new connection creation load on the database. Connections now have a
maximum lifetime between 97.5-100% of configured maxLifetime. In the case of the
default 30 minute lifetime, this generates actual lifetimes with a maximum deviation
of 45 seconds. Currently, no attempt is made to further avoid clustering that may
occur due to randomness.
* Ongoing com.zaxxer.hikari.metrics refactors. This is not considered public API until
such time as we announce it. Caveat lector.
* Performance improvements in the getConnection()/close() hot path.
* issue 452: fixed race condition when creating an rapidly ramping connections in the
pool.
* issue 415: removed use of java.beans classes to allow use of HikariCP with the
Zulu JRE compact3 profile.
* issue 406: execute validation query during connection setup to make sure it is
valid SQL.
Changes in 2.3.12
* Fixed issue with proxy generation whereby the generated classes contain the
major version number for Java 8, which makes them incompatible with the Java 7
runtime.
Changes in 2.4.1
* issue 380: housekeeper was not being scheduled in the case of a user specified
ScheduledExecutorService instance.
* issue 340: rollback change that elides setting the readonly property if the user
never explicitly configured it. See discussion in the Github issue tracker. Also
fixes binary ABI breakage between 2.3.9 and 2.4.0.
* issue 379: stop closing idle connections, to keep minimumIdle connections in pool
* issue 375: fixed InvalidPathException in HikariConfig
* issue 362: fixed NullPointerException in closing connection (closing statements)
* issue 357: allow altering the username & password through JMX at runtime
* issue 349: handle integer Transaction isolation level
* Throw SQLTransientConnectionException instead of SQLTimeoutException
* for validating connection, if network time out is set, do not set query timeout too
* ResultSet.getStatement() should return StatementProxy
Changes in 2.4.0
* Consolidated distribution into single JVM target (Java 7/8). Java 6 support has
entered maintenance mode, bug fixes will continue on the 2.3.x branch.
* Removed runtime dependency on Javassist by pre-generating proxy classes at build-time.
* Significantly reduced overhead, and increased reliability, of ConcurrentBag.
* Reduced garbage generation by 2-3x.
* Add connection soft-eviction and replacement if backward system clock motion or
significant forward jumps (greater than 1 minute) are detected.
* Pool configuration properties and DataSource methods previously marked as
@Deprecated have been removed.
* Deprecated HikariDataSource.shutdown() in favor of close().
* Improve shutdown performance.
* Allow user specified ScheduledThreadPoolExecutor for housekeeping timer. Useful
in applications with dozens or hundreds of pools in the same JVM.
* Reduce overhead and accuracy of Dropwizard gauges.
Changes in 2.3.7
* Try harder at resolving the driver by various means when both driverClassName and jdbcUrl
have been specified.
* Allow a specifically set DataSource instance to override other settings such as jdbcUrl,
dataSourceClassName, or driverClassName.
* Fixed issue where, in the case of a driver-based configuration (jdbcUrl), we were not
initialising the network timeout Executor.
* Fixed race condition uncovered during load-testing in which the connections in the pool
can spike to the maximum pool size when many connections reach their maxLifetime at the
same time.
Changes in 2.3.6
* Allow explicit definition of driverClassName to override DriverManager.getDriver(url)
located driver.
* Fixed a rare issue where a Connection that is held out of the pool, and never used by
the holding thread, upon returning to the pool might be given to another thread without
an aliveness test.
Changes in 2.3.5
* Fixed regression caused by enhancement #279 that imposed a runtime dependency on
Dropwizard metrics.
Changes in 2.3.4
* Fixed class cast exception when setting the HealthCheckRegistry via JNDI lookup.
* Allow Dropwizard MetricRegistry/HealthCheckRegistry to be set after pool startup --
one time only.
* Make logger in BaseHikariPool non-static and use getClass() to log messages as the
implementation class rather than as BaseHikariPool.
* Removed deprecation from connectionInitSql, it will be allowed.
* Made suspect/resume lock non-static (should be be shared across pools).
* Improved unwrap() behavior in the Hibernate HikariConnectionProvider.
* Improved leak detection log
Changes in 2.3.3
* Fixed bad interaction with PostgeSQL JDBC driver whereby a SQLException thrown by
PostgreSQL where the getNextException() call returns the original exception and causes
an infinite loop in HikariCP (and eventual stack overflow).
* Throw a typed Exception rather than a simple RuntimeException when pool initialization
fails.
* Allow Dropwizard Metrics and HealthChecks to be configured by a JNDI lookup.
Changes in 2.3.2
* Add support for Dropwizard HealthChecks through the introduction of two initial health
checks: ConnectivityCheck and Connection99Percent. See the Github project wiki for
documentation.
* Allow a lower maxLifetime setting of 30 seconds (compared to previous 120 second limit)
* Improve the message displayed when a connection leak is detected.
* Fixed a bug where Connection.setNetworkTimeout() was called on an already closed connection
resulting in a warning log from the AS400 JDBC driver.
Changes in 2.3.1
* Work around a bug in the MySQL Connector/J implementation of Connection.setNetworkTimeout()
that results in non-deterministic asynchronous application of the timeout, resulting in an
NPE from the MySQL driver when setNetworkTimeout() is followed immediately by close().
* Introduced a separate validationTimeout property, distict from connectionTimeout, to allow
greater control for some deployments that desire a long (or infinite) connectionTimeout
but expect the aliveness check to succeed for fail within a different (shorter) amount of
time.
Changes in 2.3.0
* Support pool suspend/resume to support certain failover scenarios.
* Fix theoretical race in JDBC 4.0 detection support.
* Improve shutdown() semantics to avoid exceptions as connections are forcefully
aborted.
* Unregister Codahale metrics at shutdown, if metrics are enabled.
* Major internal project layout restructuring to allow shared use of common code
between the Java 6/7 and Java 8 versions.
* Fixed bug where two pools in the same VM (and ClassLoading domain), using drivers
with differing JDBC support levels, would fail unless both pools were using
connectionTestQuery.
* Improved timeliness of maxLifetime evictions, while increasing performance of
getConnection() slightly as a side-effect.
* Fixed bug in HikariDataSource unwrap() semantics.
* Allow a lower leakDetectionThreshold of 2 seconds.
* Fixed bug when using the HikariJNDIFactory that required the presence of
Codahale metrics.
* Support initializationFailFast even when minimumIdle = 0
* Log internal pool inconsistencies rather than throwing exceptions that might
disrupt internal executors.
* Guard against poor or unreliable System.nanoTime() implementations.
Changes in 2.2.5
* Fixes for Java 6 compatibility.
* Implement full transaction state tracking. This allows HikariCP to bypass
the automatic rollback when connections are returned to the pool if the
transaction state is "clean".
* Rename MBean closeIdleConnections() to softEvictConnections() and implement
"evict on return" semantics.
* Fixed bug in code that sets HikariConfig values from a Properties instance
that prevented defaults from being read properly.
* Fixed an obscure bug in connection creation with a driver that throws an
exception when setTransactionIsolation() is called with the value returned
by getTransactionIsolation(). We now bypass setTransactionIsolation() if
the user has not configured an isolation level (using the default).
* Fix a bug where DataSource.loginTimeout() was always being set to 1 second.
* Fix bug where some drivers return 0 from Connection.getNetworkTimeout(),
and yet throw SQLFeatureNotSupportedException when setNetworkTimeout() is
called. This broke they way that HikariCP had implemented JDBC 4.1 support
detection.
Changes in 2.2.4
* Generate proxy classes into the same protection domain as the HikariCP
loaded classes. This solves issues with signed jars.
* Improve accuracy of pool statistics available to JMX and logged at debug
level (at a slight performance cost).
* Fixed issue where after a database down condition, and when minimumIdle is
set to 0, when the database connectivity is restored the connections could
ramp up to the maximum pool size. Eventually, idleTimeout and maxLifetime
would restore normal pool conditions, but it was still undesirable behavior.
* Improved connection timeout handling by using Connection.setNetworkTimeout()
if available (JDBC 4.1).
* driverClassName is no longer a required property when jdbcUrl is specified.
Omitting this property only works for compliant drivers.
* Add auto-detection of support for Statement.setQueryTimeout() used in the
alive check. Fixes failures with test queries on the PostgreSQL driver
when not using JDBC4 isValid() alive checks.
* The pool now defaults to fail-fast initialization. If you need to start
your application without/before the database, you will need to explicitly
set initializationFailFast to false.
* Dropwizard/Codahale metrics are now supported via the setMetricRegistry()
method in HikariConfig and in HikariDataSource.
* Fixed issue with pool initialization of MySQL after default value of
initializationFailFast property was changed to false.
* Further shadow runtime dependency on Codahale metrics from reflection
performed by Spring and other IoC containers.
* Fix issue where network timeout was not properly restored to its default
value after modifying it for the duration of the addConnection() method.
Changes in 2.1.0
* Significant internal refactor supporting creation of new proxy instances
(throwaway) around Connections for each call to getConnection(). This
can avoid issues where a thread continues to try to use a connection
after it is closed [returned to the pool].
* Allow HikariConfig(String propertyFileName) to load properties file from
classloader as a stream, with fall-back to the file-system.
* Allow loading of properties file specified by -Dhikaricp.configurationFile
system property when using the default HikariConfig() or HikariDataSource()
constructors.
* Fixed accounting issue with totalConnections when aborting connections
during shutdown, causing a warning message to be logged.
* Fixed regression in Java 8 codeline that would prevent minimumIdle from
being set before maxPoolSize.
* Fixed regression with Tomcat carping about ThreadLocal variables held after
web application restart
* Change to make HikariConfig.getTransactionIsolation()/setTransactionIsolation()
follow proper bean semantics.
* Fixed issue where connections created in the pool would skip the alive check
the first time they were used.
Changes in 2.0.1
* Split project into Java 6/7 and Java 8 components.
* Fixed issue in JNDI object factory which would not allow JNDI-defined
DataSource properties to pass-thru to the pool.
* Fixed issue where under certain conditions getConnection() could
timeout prematurely.
* Fixed issue where user-defined pool name would be overridden by the
automatically generated name.
* Fixed NPE when one of either username and password is defined, and the
other is null.
* Fixed issue tracking the statements when there are mixed statement
types (Statement, PreparedStatement, etc.) open on the connection and
the number of unclosed statements exceeds 32.
* Fixed issue where housekeeping threads would add idle connections
even when minimumIdle was 0.
* Fixed issue where Wrapper.isWrapperFor() and Wrapper.unwrap() calls
did not recurse as per specification.
* HikariDataSource now implements the Closable interface.
* Integrated change to allow specifying a ThreadGroup for thread
creation is certain restricted environments.
Changes in 1.4.0
*) Fix bug that did not allow minIdle property to be set.
Changes in 1.3.9
*) Added pool name to housekeeping thread name to make thread dumps
more meaningful in containers with multiple pools.
*) Improved shutdown semantics; make a concerted effort to close
idle connections and abort or close active connections.
*) Performance enhancements.
Changes in 1.3.8
*) Fixed incorrect logic when using JDBC4 isValid() test for alive
status of connection.
Changes in 1.3.7
*) Added JNDI object factory (com.zaxxer.hikari.HikariJNDIFactory)
for Tomcat and other containers that prefer JNDI-registered DataSource
factories.
*) Fix NPE that can occur when connections cannot be created and
callers to getConnection() timeout.
*) Various bug fixes and minor enhancements.
Changes in 1.3.6
*) Include connection failure cause in calls to getConnection() that
timeout (due to connection failure). Removed chatty logging.
*) Java8 Compatibility fixes.
*) Include pool name in logging messages. Thanks for the contribution
@jaredstehler.
Changes in 1.3.5
*) Fixed a regression in the Javassist code generation.
*) Various bug fixes and minor enhancements.
Changes in 1.3.4
*) Added new property isolateInternalQueries used to control whether
internal pool queries such as connection alive tests are isolated
in their own transaction.
*) Added properties for DriverManager (driverClassName) and JDBC URL-based
(jdbcUrl) configuration. 1999 called and wants its JDBC driver back.
*) Added new username and password properties to allow default authentication
for connections.
*) Added support for the getConnection(username, password) method signature
to HikariDataSource.
*) Added new property readOnly to control the default read-only status
of connections in the pool.
*) Deprecated acquireIncrement property.
*) Deprecated acquireRetries property.
*) Deprecated acquireRetryDelay property.
*) Deprecated minimumPoolSize property.
*) Added new property minimumIdle used to control the minimum number of
idle connections the pool should try to maintain on a running basis.
*) Added evictConnection(Connection) method to HikariDataSource to allow
special cases where users wish to forcibly eject a connection from
the pool. To use used cautiously, read the JavaDoc before using.
*) Various bug fixes and minor enhancements.
Changes in 1.3.3
*) Removed shared state contention that was causing excessive CPU cache-line
flushing. Nearly 4x improvement in Connection acquisition/release
performance.
*) Fixed issue with Tomcat carping about ThreadLocal variables held after
web application restart.
*) Fixed issue where the maximum configured connections could be overrun
during large burst requests for connections.
Changes in 1.3.2
*) Java 6 compatibility.
*) HikariDataSource now extends HikariConfig, so pool properties can be
set directly on a HikariDataSource without need to create a HikariConfig.
The cost of doing so is a small runtime cost due to the fact that an
"is initialized" check must be performed on every invocation of
getConnection() due to lazy initialization of the pool.
*) Added Sybase-specific disconnect error codes to SQLException snooping.
*) Added HikariConfig.setCatalog() method to set DataSource catalog.
*) Add DataSource.close() method that is synonymous with shutdown().
*) More performance improvements (never ending).
*) Moved benchmarks to https://github.com/brettwooldridge/HikariCP-benchmark
Changes in 1.3.0
*) Pool is now backed by a custom lock-less ConcurrentBag that
provides superior performance to LinkedBlockingQueue and
LinkedTransferQueue for usage patterns of connection pools.
*) Fixed bugs reported against the 1.2.9 release.
*) Added more detailed logging for broken connections and failures
during new connection creation.
Changes in 1.2.9
*) Added a fail-fast option for pool initialization. If enabled, a
RuntimeException will be thrown if there are errors during pool
initialization.
*) Made the registration of the HikariCP MBeans optional. They now
default to not being registered. Registering them causes a minor
performance hit due to additional pool data collection in
HikariDataSource.getConnection().
*) Added the SQLException message to the log entry when an exception
occurs during physical connection acquisition.
*) Implemented an orderly shutdown of the pool via the shutdown() method
on HikariDataSource.
*) Listened to "Adele - Live At The Royal Albert Hall" on endless loop.
Changes in 1.2.8
*) Fixed a critical bug introduced in 1.2.7 occurring when the number of
concurrently open statements exceeds sixteen.
Changes in 1.2.7
*) Finally achieved performance parity between the generated delegates
and the former method of instrumenting driver classes directly.
*) Improved generated delegate code. Removed unnecessary casts, moved
to a static proxy factory rather than a singleton (performance win).
*) Improved performance of FastStatementList (primary source of speed-up
to reach parity with former instrumentation code).
*) Removed aliveness check on connection creation.
*) Track connection isolation level and only reset if the state has
become "dirty". Avoids unnecessary round trip to the DB during the
aliveness check.
*) Added interface IConnectionCustomizer and related HikariConfig
property 'connectionCustomizerClassName' to allow users to specify
a connection customization implementation.
Changes in 1.2.6
*) Fixed regression that caused IndexOutOfBounds when multiple unclosed
Statements existed at the time of Connection.close().
*) Fixed incorrect pom.xml dependency on Hibernate.
Changes in 1.2.5
*) Instrumentation mode (agent) removed due to narrowing gap between
delegation mode and instrumentation (and to simplify the code base).
*) Added setDataSource() to HikariConfig to allow a DataSource instance
to be explicitly wrapped by the pool. Only available when creating
HikariConfig programmatically or constructing HikariConfig from a
java.util.Properties instance.
*) Fixed Hibernate threading issue (certain usage patterns) introduced
in 1.2.2.
*) Fixed issue observed with PostgreSQL whereby the query that tests the
connection for "aliveness" also starts a transaction (when auto-commit
is false), thereby causing a later failure when we tried to set the
transaction isolation level.
*) Fixed issue where idleTimeout could not be set to 0, thereby disabling
it. Incorrect value validation caused 0 to be rejected as a valid value.
Changes in 1.2.4
*) Fix another Hibernate-related issue whereby an NPE is encountered when
a thread that was not the thread that obtained a Connection tries to
interact with that Connection.
Changes in 1.2.3
*) Fix internal (but suppressed) exception during rollback of connections
returned to the pool with auto-commit turned off.
*) Fix a reflection issue that causes Hibernate failures due to the
CallableStatement interface being incorrectly injected into statement
proxies that are PreparedStatement or Statement instances.
Changes in 1.2.2
*) Perform a rollback() on connections returned to the pool with
auto commit disabled.
*) Add a constructor for HikariConfig that accepts a Properties
object.
*) Speed improvements for delegate mode.
*) Fix a bug where connection timeouts could not be disabled.
*) Permit setting the DataSource logWriter either on the HikariDataSource
or via addDataSourceProperty() on the HikariConfig.
*) Add transactionIsolation property to allow setting the default
transaction isolation level for connections.
Changes in 1.2.1
*) Clear SQL warnings before returning a connection to the user.
*) Added asynchronous connection backfill strategy that triggers
when the pool becomes empty as a result of dispatching a
connection.
*) Changed default acquireIncrement to 1, set minimum timeout of
100ms for acquiring a connection.
Changes in 1.1.9
*) Added connectionInitSql property to allow setting connection
properties when a new connection is created.
*) Added setDataSourceProperties() setter to HikariConfig to
allow easier configuration though Spring.
HikariCP-HikariCP-2.7.1/LICENSE 0000664 0000000 0000000 00000024041 13154316420 0015610 0 ustar 00root root 0000000 0000000 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:
You must give any other recipients of the Work or Derivative Works a copy of
this License; and
You must cause any modified files to carry prominent notices stating that You
changed the files; and
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
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.
HikariCP-HikariCP-2.7.1/README.md 0000664 0000000 0000000 00000072460 13154316420 0016072 0 ustar 00root root 0000000 0000000
[![][Build Status img]][Build Status]
[![][Coverage Status img]][Coverage Status]
[![][Dependency Status img]][Dependency Status]
[![][license img]][license]
[![][Maven Central img]][Maven Central]
[![][Javadocs img]][Javadocs]
Fast, simple, reliable. HikariCP is a "zero-overhead" production ready JDBC connection pool. At roughly 130Kb, the library is very light. Read about [how we do it here](https://github.com/brettwooldridge/HikariCP/wiki/Down-the-Rabbit-Hole).
**"Simplicity is prerequisite for reliability."**
- *Edsger Dijkstra*
----------------------------------------------------
_Java 8 maven artifact:_
```xml
com.zaxxerHikariCP2.7.0
```
_Java 9 Early Access maven artifact:_
```xml
com.zaxxerHikariCP-java9ea2.6.1
```
_Java 7 maven artifact (*maintenance mode*):_
```xml
com.zaxxerHikariCP-java72.4.12
```
_Java 6 maven artifact (*maintenance mode*):_
```xml
com.zaxxerHikariCP-java62.3.13
```
Or [download from here](http://search.maven.org/#search%7Cga%7C1%7Ccom.zaxxer.hikaricp).
----------------------------------------------------
##### JMH Benchmarks :checkered_flag:
Microbenchmarks were created to isolate and measure the overhead of pools using the [JMH microbenchmark framework](http://openjdk.java.net/projects/code-tools/jmh/). You can checkout the [HikariCP benchmark project for details](https://github.com/brettwooldridge/HikariCP-benchmark) and review/run the benchmarks yourself.
* One *Connection Cycle* is defined as single ``DataSource.getConnection()``/``Connection.close()``.
* One *Statement Cycle* is defined as single ``Connection.prepareStatement()``, ``Statement.execute()``, ``Statement.close()``.
1 Versions: HikariCP 2.6.0, commons-dbcp2 2.1.1, Tomcat 8.0.24, Vibur 16.1, c3p0 0.9.5.2, Java 8u111 2 Intel Core i7-3770 CPU @ 3.40GHz 3 Uncontended benchmark: 32 threads/32 connections, Contended benchmark: 32 threads, 16 connections 4 Apache Tomcat fails to complete the Statement benchmark when the Tomcat StatementFinalizer is used due to excessive garbage collection times 5 Apache DBCP fails to complete the Statement benchmark due to excessive garbage collection times
----------------------------------------------------
#### Analyses :microscope:
#### Spike Demand Pool Comparison
Anaylsis of HikariCP v2.6, in comparison to other pools, in relation to a unique "spike demand" load.
The customer's environment imposed a high cost of new connection acquisition, and a requirement for a dynamically-sized pool, but yet a need for responsiveness to request spikes. Read about the spike demand handling [here](https://github.com/brettwooldridge/HikariCP/blob/dev/documents/Welcome-To-The-Jungle.md).
#### You're [probably] doing it wrong.
AKA *"What you probably didn't know about connection pool sizing"*. Watch a video from the Oracle Real-world Performance group, and learn about why connection pools do not need to be sized as large as they often are. In fact, oversized connection pools have a clear and demonstrable *negative* impact on performance; a 50x difference in the case of the Oracle demonstration. [Read on to find out](https://github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing).
#### WIX Engineering Analysis
We'd like to thank the guys over at WIX for the unsolicited and deep write-up about HikariCP on their [engineering blog](http://engineering.wix.com/2015/04/28/how-does-hikaricp-compare-to-other-connection-pools/). Take a look if you have time.
Any value greater than zero will be treated as a timeout for pool initialization.
* The calling thread will be blocked from continuing until a successful connection
* to the database, or until the timeout is reached. If the timeout is reached, then
* a {@code PoolInitializationException} will be thrown.
*
A value of zero will not prevent the pool from starting in the
* case that a connection cannot be obtained. However, upon start the pool will
* attempt to obtain a connection and validate that the {@code connectionTestQuery}
* and {@code connectionInitSql} are valid. If those validations fail, an exception
* will be thrown. If a connection cannot be obtained, the validation is skipped
* and the the pool will start and continue to try to obtain connections in the
* background. This can mean that callers to {@code DataSource#getConnection()} may
* encounter exceptions.
*
A value less than zero will not bypass any connection attempt and
* validation during startup, and therefore the pool will start immediately. The
* pool will continue to try to obtain connections in the background. This can mean
* that callers to {@code DataSource#getConnection()} may encounter exceptions.
*
* Note that if this timeout value is greater than or equal to zero (0), and therefore an
* initial connection validation is performed, this timeout does not override the
* {@code connectionTimeout} or {@code validationTimeout}; they will be honored before this
* timeout is applied. The default value is one millisecond.
*
* @param initializationFailTimeout the number of milliseconds before the
* pool initialization fails, or 0 to validate connection setup but continue with
* pool start, or less than zero to skip all initialization checks and start the
* pool without delay.
*/
public void setInitializationFailTimeout(long initializationFailTimeout)
{
this.initializationFailTimeout = initializationFailTimeout;
}
/**
* Get whether or not the construction of the pool should throw an exception
* if the minimum number of connections cannot be created.
*
* @return whether or not initialization should fail on error immediately
* @deprecated
*/
@Deprecated
public boolean isInitializationFailFast()
{
return initializationFailTimeout > 0;
}
/**
* Set whether or not the construction of the pool should throw an exception
* if the minimum number of connections cannot be created.
*
* @param failFast true if the pool should fail if the minimum connections cannot be created
* @deprecated
*/
@Deprecated
public void setInitializationFailFast(boolean failFast)
{
LOGGER.warn("The initializationFailFast propery is deprecated, see initializationFailTimeout");
initializationFailTimeout = (failFast ? 1 : -1);
}
public boolean isIsolateInternalQueries()
{
return isIsolateInternalQueries;
}
public void setIsolateInternalQueries(boolean isolate)
{
this.isIsolateInternalQueries = isolate;
}
@Deprecated
public boolean isJdbc4ConnectionTest()
{
return false;
}
@Deprecated
public void setJdbc4ConnectionTest(boolean useIsValid)
{
LOGGER.warn("The jdbcConnectionTest property is now deprecated, see the documentation for connectionTestQuery");
}
public MetricsTrackerFactory getMetricsTrackerFactory()
{
return metricsTrackerFactory;
}
public void setMetricsTrackerFactory(MetricsTrackerFactory metricsTrackerFactory)
{
if (metricRegistry != null) {
throw new IllegalStateException("cannot use setMetricsTrackerFactory() and setMetricRegistry() together");
}
this.metricsTrackerFactory = metricsTrackerFactory;
}
/**
* Get the Codahale MetricRegistry, could be null.
*
* @return the codahale MetricRegistry instance
*/
public Object getMetricRegistry()
{
return metricRegistry;
}
/**
* Set a Codahale MetricRegistry to use for HikariCP.
*
* @param metricRegistry the Codahale MetricRegistry to set
*/
public void setMetricRegistry(Object metricRegistry)
{
if (metricsTrackerFactory != null) {
throw new IllegalStateException("cannot use setMetricRegistry() and setMetricsTrackerFactory() together");
}
if (metricRegistry != null) {
metricRegistry = getObjectOrPerformJndiLookup(metricRegistry);
if (!(metricRegistry.getClass().getName().contains("MetricRegistry"))
&& !(metricRegistry.getClass().getName().contains("MeterRegistry"))) {
throw new IllegalArgumentException("Class must be instance of com.codahale.metrics.MetricRegistry or io.micrometer.core.instrument.MeterRegistry");
}
}
this.metricRegistry = metricRegistry;
}
private Object getObjectOrPerformJndiLookup(Object object)
{
if (object instanceof String) {
try {
InitialContext initCtx = new InitialContext();
return initCtx.lookup((String) object);
}
catch (NamingException e) {
throw new IllegalArgumentException(e);
}
}
return object;
}
/**
* Get the Codahale HealthCheckRegistry, could be null.
*
* @return the Codahale HealthCheckRegistry instance
*/
public Object getHealthCheckRegistry()
{
return healthCheckRegistry;
}
/**
* Set a Codahale HealthCheckRegistry to use for HikariCP.
*
* @param healthCheckRegistry the Codahale HealthCheckRegistry to set
*/
public void setHealthCheckRegistry(Object healthCheckRegistry)
{
if (healthCheckRegistry != null) {
healthCheckRegistry = getObjectOrPerformJndiLookup(healthCheckRegistry);
if (!(healthCheckRegistry instanceof HealthCheckRegistry)) {
throw new IllegalArgumentException("Class must be an instance of com.codahale.metrics.health.HealthCheckRegistry");
}
}
this.healthCheckRegistry = healthCheckRegistry;
}
public Properties getHealthCheckProperties()
{
return healthCheckProperties;
}
public void setHealthCheckProperties(Properties healthCheckProperties)
{
this.healthCheckProperties.putAll(healthCheckProperties);
}
public void addHealthCheckProperty(String key, String value)
{
healthCheckProperties.setProperty(key, value);
}
public boolean isReadOnly()
{
return isReadOnly;
}
public void setReadOnly(boolean readOnly)
{
this.isReadOnly = readOnly;
}
public boolean isRegisterMbeans()
{
return isRegisterMbeans;
}
public void setRegisterMbeans(boolean register)
{
this.isRegisterMbeans = register;
}
/** {@inheritDoc} */
@Override
public long getLeakDetectionThreshold()
{
return leakDetectionThreshold;
}
/** {@inheritDoc} */
@Override
public void setLeakDetectionThreshold(long leakDetectionThresholdMs)
{
this.leakDetectionThreshold = leakDetectionThresholdMs;
}
/** {@inheritDoc} */
@Override
public long getMaxLifetime()
{
return maxLifetime;
}
/** {@inheritDoc} */
@Override
public void setMaxLifetime(long maxLifetimeMs)
{
this.maxLifetime = maxLifetimeMs;
}
/** {@inheritDoc} */
@Override
public int getMaximumPoolSize()
{
return maxPoolSize;
}
/** {@inheritDoc} */
@Override
public void setMaximumPoolSize(int maxPoolSize)
{
if (maxPoolSize < 1) {
throw new IllegalArgumentException("maxPoolSize cannot be less than 1");
}
this.maxPoolSize = maxPoolSize;
}
/** {@inheritDoc} */
@Override
public int getMinimumIdle()
{
return minIdle;
}
/** {@inheritDoc} */
@Override
public void setMinimumIdle(int minIdle)
{
if (minIdle < 0) {
throw new IllegalArgumentException("minimumIdle cannot be negative");
}
this.minIdle = minIdle;
}
/**
* Get the default password to use for DataSource.getConnection(username, password) calls.
* @return the password
*/
public String getPassword()
{
return password;
}
/**
* Set the default password to use for DataSource.getConnection(username, password) calls.
* @param password the password
*/
@Override
public void setPassword(String password)
{
this.password = password;
}
/** {@inheritDoc} */
@Override
public String getPoolName()
{
return poolName;
}
/**
* Set the name of the connection pool. This is primarily used for the MBean
* to uniquely identify the pool configuration.
*
* @param poolName the name of the connection pool to use
*/
public void setPoolName(String poolName)
{
this.poolName = poolName;
}
/**
* Get the ScheduledExecutorService used for housekeeping.
*
* @return the executor
*/
@Deprecated
public ScheduledThreadPoolExecutor getScheduledExecutorService()
{
return (ScheduledThreadPoolExecutor) scheduledExecutor;
}
/**
* Set the ScheduledExecutorService used for housekeeping.
*
* @param executor the ScheduledExecutorService
*/
@Deprecated
public void setScheduledExecutorService(ScheduledThreadPoolExecutor executor)
{
this.scheduledExecutor = executor;
}
/**
* Get the ScheduledExecutorService used for housekeeping.
*
* @return the executor
*/
public ScheduledExecutorService getScheduledExecutor()
{
return scheduledExecutor;
}
/**
* Set the ScheduledExecutorService used for housekeeping.
*
* @param executor the ScheduledExecutorService
*/
public void setScheduledExecutor(ScheduledExecutorService executor)
{
this.scheduledExecutor = executor;
}
public String getTransactionIsolation()
{
return transactionIsolationName;
}
/**
* Get the default schema name to be set on connections.
*
* @return the default schema name
*/
public String getSchema() {
return schema;
}
/**
* Set the default schema name to be set on connections.
*/
public void setSchema(String schema) {
this.schema = schema;
}
/**
* Set the default transaction isolation level. The specified value is the
* constant name from the Connection class, eg.
* TRANSACTION_REPEATABLE_READ.
*
* @param isolationLevel the name of the isolation level
*/
public void setTransactionIsolation(String isolationLevel)
{
this.transactionIsolationName = isolationLevel;
}
/**
* Get the default username used for DataSource.getConnection(username, password) calls.
*
* @return the username
*/
public String getUsername()
{
return username;
}
/**
* Set the default username used for DataSource.getConnection(username, password) calls.
*
* @param username the username
*/
@Override
public void setUsername(String username)
{
this.username = username;
}
/**
* Get the thread factory used to create threads.
*
* @return the thread factory (may be null, in which case the default thread factory is used)
*/
public ThreadFactory getThreadFactory()
{
return threadFactory;
}
/**
* Set the thread factory to be used to create threads.
*
* @param threadFactory the thread factory (setting to null causes the default thread factory to be used)
*/
public void setThreadFactory(ThreadFactory threadFactory)
{
this.threadFactory = threadFactory;
}
@SuppressWarnings("StatementWithEmptyBody")
public void validate()
{
if (poolName == null) {
poolName = "HikariPool-" + generatePoolNumber();
}
else if (isRegisterMbeans && poolName.contains(":")) {
throw new IllegalArgumentException("poolName cannot contain ':' when used with JMX");
}
// treat empty property as null
catalog = getNullIfEmpty(catalog);
connectionInitSql = getNullIfEmpty(connectionInitSql);
connectionTestQuery = getNullIfEmpty(connectionTestQuery);
transactionIsolationName = getNullIfEmpty(transactionIsolationName);
dataSourceClassName = getNullIfEmpty(dataSourceClassName);
dataSourceJndiName = getNullIfEmpty(dataSourceJndiName);
driverClassName = getNullIfEmpty(driverClassName);
jdbcUrl = getNullIfEmpty(jdbcUrl);
// Check Data Source Options
if (dataSource != null) {
if (dataSourceClassName != null) {
LOGGER.warn("{} - using dataSource and ignoring dataSourceClassName.", poolName);
}
}
else if (dataSourceClassName != null) {
if (driverClassName != null) {
LOGGER.error("{} - cannot use driverClassName and dataSourceClassName together.", poolName);
// NOTE: This exception text is referenced by a Spring Boot FailureAnalyzer, it should not be
// changed without first notifying the Spring Boot developers.
throw new IllegalStateException("cannot use driverClassName and dataSourceClassName together.");
}
else if (jdbcUrl != null) {
LOGGER.warn("{} - using dataSourceClassName and ignoring jdbcUrl.", poolName);
}
}
else if (jdbcUrl != null || dataSourceJndiName != null) {
// ok
}
else if (driverClassName != null) {
LOGGER.error("{} - jdbcUrl is required with driverClassName.", poolName);
throw new IllegalArgumentException("jdbcUrl is required with driverClassName.");
}
else {
LOGGER.error("{} - dataSource or dataSourceClassName or jdbcUrl is required.", poolName);
throw new IllegalArgumentException("dataSource or dataSourceClassName or jdbcUrl is required.");
}
validateNumerics();
if (LOGGER.isDebugEnabled() || unitTest) {
logConfiguration();
}
}
private void validateNumerics()
{
if (maxLifetime != 0 && maxLifetime < SECONDS.toMillis(30)) {
LOGGER.warn("{} - maxLifetime is less than 30000ms, setting to default {}ms.", poolName, MAX_LIFETIME);
maxLifetime = MAX_LIFETIME;
}
if (idleTimeout + SECONDS.toMillis(1) > maxLifetime && maxLifetime > 0) {
LOGGER.warn("{} - idleTimeout is close to or more than maxLifetime, disabling it.", poolName);
idleTimeout = 0;
}
if (idleTimeout != 0 && idleTimeout < SECONDS.toMillis(10)) {
LOGGER.warn("{} - idleTimeout is less than 10000ms, setting to default {}ms.", poolName, IDLE_TIMEOUT);
idleTimeout = IDLE_TIMEOUT;
}
if (leakDetectionThreshold > 0 && !unitTest) {
if (leakDetectionThreshold < SECONDS.toMillis(2) || (leakDetectionThreshold > maxLifetime && maxLifetime > 0)) {
LOGGER.warn("{} - leakDetectionThreshold is less than 2000ms or more than maxLifetime, disabling it.", poolName);
leakDetectionThreshold = 0;
}
}
if (connectionTimeout < 250) {
LOGGER.warn("{} - connectionTimeout is less than 250ms, setting to {}ms.", poolName, CONNECTION_TIMEOUT);
connectionTimeout = CONNECTION_TIMEOUT;
}
if (validationTimeout < 250) {
LOGGER.warn("{} - validationTimeout is less than 250ms, setting to {}ms.", poolName, VALIDATION_TIMEOUT);
validationTimeout = VALIDATION_TIMEOUT;
}
if (maxPoolSize < 1) {
maxPoolSize = (minIdle <= 0) ? DEFAULT_POOL_SIZE : minIdle;
}
if (minIdle < 0 || minIdle > maxPoolSize) {
minIdle = maxPoolSize;
}
}
@SuppressWarnings("StatementWithEmptyBody")
private void logConfiguration()
{
LOGGER.debug("{} - configuration:", poolName);
final Set propertyNames = new TreeSet<>(PropertyElf.getPropertyNames(HikariConfig.class));
for (String prop : propertyNames) {
try {
Object value = PropertyElf.getProperty(prop, this);
if ("dataSourceProperties".equals(prop)) {
Properties dsProps = PropertyElf.copyProperties(dataSourceProperties);
dsProps.setProperty("password", "");
value = dsProps;
}
if ("initializationFailTimeout".equals(prop) && initializationFailTimeout == Long.MAX_VALUE) {
value = "infinite";
}
else if ("transactionIsolation".equals(prop) && transactionIsolationName == null) {
value = "default";
}
else if (prop.matches("scheduledExecutorService|threadFactory") && value == null) {
value = "internal";
}
else if (prop.contains("jdbcUrl") && value instanceof String) {
value = ((String)value).replaceAll("([?&;]password=)[^&#;]*(.*)", "$1$2");
}
else if (prop.contains("password")) {
value = "";
}
else if (value instanceof String) {
value = "\"" + value + "\""; // quote to see lead/trailing spaces is any
}
else if (value == null) {
value = "none";
}
LOGGER.debug((prop + "................................................").substring(0, 32) + value);
}
catch (Exception e) {
// continue
}
}
}
private void loadProperties(String propertyFileName)
{
final File propFile = new File(propertyFileName);
try (final InputStream is = propFile.isFile() ? new FileInputStream(propFile) : this.getClass().getResourceAsStream(propertyFileName)) {
if (is != null) {
Properties props = new Properties();
props.load(is);
PropertyElf.setTargetFromProperties(this, props);
}
else {
throw new IllegalArgumentException("Cannot find property file: " + propertyFileName);
}
}
catch (IOException io) {
throw new RuntimeException("Failed to read property file", io);
}
}
private int generatePoolNumber()
{
// Pool number is global to the VM to avoid overlapping pool numbers in classloader scoped environments
synchronized (System.getProperties()) {
final int next = Integer.getInteger("com.zaxxer.hikari.pool_number", 0) + 1;
System.setProperty("com.zaxxer.hikari.pool_number", String.valueOf(next));
return next;
}
}
public void copyState(HikariConfig other)
{
for (Field field : HikariConfig.class.getDeclaredFields()) {
if (!Modifier.isFinal(field.getModifiers())) {
field.setAccessible(true);
try {
field.set(other, field.get(this));
}
catch (Exception e) {
throw new RuntimeException("Failed to copy HikariConfig state: " + e.getMessage(), e);
}
}
}
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/HikariConfigMXBean.java 0000664 0000000 0000000 00000016067 13154316420 0027051 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari;
/**
* The javax.management MBean for a Hikari pool configuration.
*
* @author Brett Wooldridge
*/
public interface HikariConfigMXBean
{
/**
* Get the maximum number of milliseconds that a client will wait for a connection from the pool. If this
* time is exceeded without a connection becoming available, a SQLException will be thrown from
* {@link javax.sql.DataSource#getConnection()}.
*
* @return the connection timeout in milliseconds
*/
long getConnectionTimeout();
/**
* Set the maximum number of milliseconds that a client will wait for a connection from the pool. If this
* time is exceeded without a connection becoming available, a SQLException will be thrown from
* {@link javax.sql.DataSource#getConnection()}.
*
* @param connectionTimeoutMs the connection timeout in milliseconds
*/
void setConnectionTimeout(long connectionTimeoutMs);
/**
* Get the maximum number of milliseconds that the pool will wait for a connection to be validated as
* alive.
*
* @return the validation timeout in milliseconds
*/
long getValidationTimeout();
/**
* Sets the maximum number of milliseconds that the pool will wait for a connection to be validated as
* alive.
*
* @param validationTimeoutMs the validation timeout in milliseconds
*/
void setValidationTimeout(long validationTimeoutMs);
/**
* This property controls the maximum amount of time (in milliseconds) that a connection is allowed to sit
* idle in the pool. Whether a connection is retired as idle or not is subject to a maximum variation of +30
* seconds, and average variation of +15 seconds. A connection will never be retired as idle before this timeout.
* A value of 0 means that idle connections are never removed from the pool.
*
* @return the idle timeout in milliseconds
*/
long getIdleTimeout();
/**
* This property controls the maximum amount of time (in milliseconds) that a connection is allowed to sit
* idle in the pool. Whether a connection is retired as idle or not is subject to a maximum variation of +30
* seconds, and average variation of +15 seconds. A connection will never be retired as idle before this timeout.
* A value of 0 means that idle connections are never removed from the pool.
*
* @param idleTimeoutMs the idle timeout in milliseconds
*/
void setIdleTimeout(long idleTimeoutMs);
/**
* This property controls the amount of time that a connection can be out of the pool before a message is
* logged indicating a possible connection leak. A value of 0 means leak detection is disabled.
*
* @return the connection leak detection threshold in milliseconds
*/
long getLeakDetectionThreshold();
/**
* This property controls the amount of time that a connection can be out of the pool before a message is
* logged indicating a possible connection leak. A value of 0 means leak detection is disabled.
*
* @param leakDetectionThresholdMs the connection leak detection threshold in milliseconds
*/
void setLeakDetectionThreshold(long leakDetectionThresholdMs);
/**
* This property controls the maximum lifetime of a connection in the pool. When a connection reaches this
* timeout, even if recently used, it will be retired from the pool. An in-use connection will never be
* retired, only when it is idle will it be removed.
*
* @return the maximum connection lifetime in milliseconds
*/
long getMaxLifetime();
/**
* This property controls the maximum lifetime of a connection in the pool. When a connection reaches this
* timeout, even if recently used, it will be retired from the pool. An in-use connection will never be
* retired, only when it is idle will it be removed.
*
* @param maxLifetimeMs the maximum connection lifetime in milliseconds
*/
void setMaxLifetime(long maxLifetimeMs);
/**
* The property controls the maximum size that the pool is allowed to reach, including both idle and in-use
* connections. Basically this value will determine the maximum number of actual connections to the database
* backend.
*
* When the pool reaches this size, and no idle connections are available, calls to getConnection() will
* block for up to connectionTimeout milliseconds before timing out.
*
* @return the minimum number of connections in the pool
*/
int getMinimumIdle();
/**
* The property controls the minimum number of idle connections that HikariCP tries to maintain in the pool,
* including both idle and in-use connections. If the idle connections dip below this value, HikariCP will
* make a best effort to restore them quickly and efficiently.
*
* @param minIdle the minimum number of idle connections in the pool to maintain
*/
void setMinimumIdle(int minIdle);
/**
* The property controls the maximum number of connections that HikariCP will keep in the pool,
* including both idle and in-use connections.
*
* @return the maximum number of connections in the pool
*/
int getMaximumPoolSize();
/**
* The property controls the maximum size that the pool is allowed to reach, including both idle and in-use
* connections. Basically this value will determine the maximum number of actual connections to the database
* backend.
*
* When the pool reaches this size, and no idle connections are available, calls to getConnection() will
* block for up to connectionTimeout milliseconds before timing out.
*
* @param maxPoolSize the maximum number of connections in the pool
*/
void setMaximumPoolSize(int maxPoolSize);
/**
* Set the password used for authentication. Changing this at runtime will apply to new connections only.
* Altering this at runtime only works for DataSource-based connections, not Driver-class or JDBC URL-based
* connections.
*
* @param password the database password
*/
void setPassword(String password);
/**
* Set the username used for authentication. Changing this at runtime will apply to new connections only.
* Altering this at runtime only works for DataSource-based connections, not Driver-class or JDBC URL-based
* connections.
*
* @param username the database username
*/
void setUsername(String username);
/**
* The name of the connection pool.
*
* @return the name of the connection pool
*/
String getPoolName();
} HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/HikariDataSource.java 0000664 0000000 0000000 00000025457 13154316420 0026646 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari;
import java.io.Closeable;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.sql.DataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.zaxxer.hikari.metrics.MetricsTrackerFactory;
import com.zaxxer.hikari.pool.HikariPool;
import com.zaxxer.hikari.pool.HikariPool.PoolInitializationException;
/**
* The HikariCP pooled DataSource.
*
* @author Brett Wooldridge
*/
public class HikariDataSource extends HikariConfig implements DataSource, Closeable
{
private static final Logger LOGGER = LoggerFactory.getLogger(HikariDataSource.class);
private final AtomicBoolean isShutdown = new AtomicBoolean();
private final HikariPool fastPathPool;
private volatile HikariPool pool;
/**
* Default constructor. Setters be used to configure the pool. Using
* this constructor vs. {@link #HikariDataSource(HikariConfig)} will
* result in {@link #getConnection()} performance that is slightly lower
* due to lazy initialization checks.
*/
public HikariDataSource()
{
super();
fastPathPool = null;
}
/**
* Construct a HikariDataSource with the specified configuration.
*
* @param configuration a HikariConfig instance
*/
public HikariDataSource(HikariConfig configuration)
{
configuration.validate();
configuration.copyState(this);
LOGGER.info("{} - Starting...", configuration.getPoolName());
pool = fastPathPool = new HikariPool(this);
LOGGER.info("{} - Start completed.", configuration.getPoolName());
}
/** {@inheritDoc} */
@Override
public Connection getConnection() throws SQLException
{
if (isClosed()) {
throw new SQLException("HikariDataSource " + this + " has been closed.");
}
if (fastPathPool != null) {
return fastPathPool.getConnection();
}
// See http://en.wikipedia.org/wiki/Double-checked_locking#Usage_in_Java
HikariPool result = pool;
if (result == null) {
synchronized (this) {
result = pool;
if (result == null) {
validate();
LOGGER.info("{} - Starting...", getPoolName());
try {
pool = result = new HikariPool(this);
}
catch (PoolInitializationException pie) {
if (pie.getCause() instanceof SQLException) {
throw (SQLException) pie.getCause();
}
else {
throw pie;
}
}
LOGGER.info("{} - Start completed.", getPoolName());
}
}
}
return result.getConnection();
}
/** {@inheritDoc} */
@Override
public Connection getConnection(String username, String password) throws SQLException
{
throw new SQLFeatureNotSupportedException();
}
/** {@inheritDoc} */
@Override
public PrintWriter getLogWriter() throws SQLException
{
HikariPool p = pool;
return (p != null ? p.getUnwrappedDataSource().getLogWriter() : null);
}
/** {@inheritDoc} */
@Override
public void setLogWriter(PrintWriter out) throws SQLException
{
HikariPool p = pool;
if (p != null) {
p.getUnwrappedDataSource().setLogWriter(out);
}
}
/** {@inheritDoc} */
@Override
public void setLoginTimeout(int seconds) throws SQLException
{
HikariPool p = pool;
if (p != null) {
p.getUnwrappedDataSource().setLoginTimeout(seconds);
}
}
/** {@inheritDoc} */
@Override
public int getLoginTimeout() throws SQLException
{
HikariPool p = pool;
return (p != null ? p.getUnwrappedDataSource().getLoginTimeout() : 0);
}
/** {@inheritDoc} */
@Override
public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException
{
throw new SQLFeatureNotSupportedException();
}
/** {@inheritDoc} */
@Override
@SuppressWarnings("unchecked")
public T unwrap(Class iface) throws SQLException
{
if (iface.isInstance(this)) {
return (T) this;
}
HikariPool p = pool;
if (p != null) {
final DataSource unwrappedDataSource = p.getUnwrappedDataSource();
if (iface.isInstance(unwrappedDataSource)) {
return (T) unwrappedDataSource;
}
if (unwrappedDataSource != null) {
return unwrappedDataSource.unwrap(iface);
}
}
throw new SQLException("Wrapped DataSource is not an instance of " + iface);
}
/** {@inheritDoc} */
@Override
public boolean isWrapperFor(Class iface) throws SQLException
{
if (iface.isInstance(this)) {
return true;
}
HikariPool p = pool;
if (p != null) {
final DataSource unwrappedDataSource = p.getUnwrappedDataSource();
if (iface.isInstance(unwrappedDataSource)) {
return true;
}
if (unwrappedDataSource != null) {
return unwrappedDataSource.isWrapperFor(iface);
}
}
return false;
}
/** {@inheritDoc} */
@Override
public void setMetricRegistry(Object metricRegistry)
{
boolean isAlreadySet = getMetricRegistry() != null;
super.setMetricRegistry(metricRegistry);
HikariPool p = pool;
if (p != null) {
if (isAlreadySet) {
throw new IllegalStateException("MetricRegistry can only be set one time");
}
else {
p.setMetricRegistry(super.getMetricRegistry());
}
}
}
/** {@inheritDoc} */
@Override
public void setMetricsTrackerFactory(MetricsTrackerFactory metricsTrackerFactory)
{
boolean isAlreadySet = getMetricsTrackerFactory() != null;
super.setMetricsTrackerFactory(metricsTrackerFactory);
HikariPool p = pool;
if (p != null) {
if (isAlreadySet) {
throw new IllegalStateException("MetricsTrackerFactory can only be set one time");
}
else {
p.setMetricsTrackerFactory(super.getMetricsTrackerFactory());
}
}
}
/** {@inheritDoc} */
@Override
public void setHealthCheckRegistry(Object healthCheckRegistry)
{
boolean isAlreadySet = getHealthCheckRegistry() != null;
super.setHealthCheckRegistry(healthCheckRegistry);
HikariPool p = pool;
if (p != null) {
if (isAlreadySet) {
throw new IllegalStateException("HealthCheckRegistry can only be set one time");
}
else {
p.setHealthCheckRegistry(super.getHealthCheckRegistry());
}
}
}
/**
* Get the {@code HikariPoolMXBean} for this HikariDataSource instance. If this method is called on
* a {@code HikariDataSource} that has been constructed without a {@code HikariConfig} instance,
* and before an initial call to {@code #getConnection()}, the return value will be {@code null}.
*
* @return the {@code HikariPoolMXBean} instance, or {@code null}.
*/
public HikariPoolMXBean getHikariPoolMXBean()
{
return pool;
}
/**
* Get the {@code HikariConfigMXBean} for this HikariDataSource instance.
*
* @return the {@code HikariConfigMXBean} instance.
*/
public HikariConfigMXBean getHikariConfigMXBean()
{
return this;
}
/**
* Evict a connection from the pool. If the connection has already been closed (returned to the pool)
* this may result in a "soft" eviction; the connection will be evicted sometime in the future if it is
* currently in use. If the connection has not been closed, the eviction is immediate.
*
* @param connection the connection to evict from the pool
*/
public void evictConnection(Connection connection)
{
HikariPool p;
if (!isClosed() && (p = pool) != null && connection.getClass().getName().startsWith("com.zaxxer.hikari")) {
p.evictConnection(connection);
}
}
/**
* Suspend allocation of connections from the pool. All callers to getConnection()
* will block indefinitely until resumePool() is called.
*
* @deprecated Call the {@code HikariPoolMXBean#suspendPool()} method on the {@code HikariPoolMXBean}
* obtained by {@code #getHikariPoolMXBean()} or JMX lookup.
*/
@Deprecated
public void suspendPool()
{
HikariPool p;
if (!isClosed() && (p = pool) != null) {
p.suspendPool();
}
}
/**
* Resume allocation of connections from the pool.
*
* @deprecated Call the {@code HikariPoolMXBean#resumePool()} method on the {@code HikariPoolMXBean}
* obtained by {@code #getHikariPoolMXBean()} or JMX lookup.
*/
@Deprecated
public void resumePool()
{
HikariPool p;
if (!isClosed() && (p = pool) != null) {
p.resumePool();
}
}
/**
* Shutdown the DataSource and its associated pool.
*/
@Override
public void close()
{
if (isShutdown.getAndSet(true)) {
return;
}
HikariPool p = pool;
if (p != null) {
try {
LOGGER.info("{} - Shutdown initiated...", getPoolName());
p.shutdown();
LOGGER.info("{} - Shutdown completed.", getPoolName());
}
catch (InterruptedException e) {
LOGGER.warn("{} - Interrupted during closing", getPoolName(), e);
Thread.currentThread().interrupt();
}
}
}
/**
* Determine whether the HikariDataSource has been closed.
*
* @return true if the HikariDataSource has been closed, false otherwise
*/
public boolean isClosed()
{
return isShutdown.get();
}
/**
* Shutdown the DataSource and its associated pool.
*
* @deprecated This method has been deprecated, please use {@link #close()} instead
*/
@Deprecated
public void shutdown()
{
LOGGER.warn("The shutdown() method has been deprecated, please use the close() method instead");
close();
}
/** {@inheritDoc} */
@Override
public String toString()
{
return "HikariDataSource (" + pool + ")";
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/HikariJNDIFactory.java 0000664 0000000 0000000 00000006541 13154316420 0026661 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013,2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import java.util.Set;
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 com.zaxxer.hikari.util.PropertyElf;
/**
* A JNDI factory that produces HikariDataSource instances.
*
* @author Brett Wooldridge
*/
public class HikariJNDIFactory implements ObjectFactory
{
@Override
synchronized public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable environment) throws Exception
{
// We only know how to deal with javax.naming.Reference that specify a class name of "javax.sql.DataSource"
if (!(obj instanceof Reference)) {
return null;
}
Reference ref = (Reference) obj;
if (!"javax.sql.DataSource".equals(ref.getClassName())) {
throw new NamingException(ref.getClassName() + " is not a valid class name/type for this JNDI factory.");
}
Set hikariPropSet = PropertyElf.getPropertyNames(HikariConfig.class);
Properties properties = new Properties();
Enumeration enumeration = ref.getAll();
while (enumeration.hasMoreElements()) {
RefAddr element = enumeration.nextElement();
String type = element.getType();
if (type.startsWith("dataSource.") || hikariPropSet.contains(type)) {
properties.setProperty(type, element.getContent().toString());
}
}
return createDataSource(properties, nameCtx);
}
private DataSource createDataSource(final Properties properties, final Context context) throws NamingException
{
String jndiName = properties.getProperty("dataSourceJNDI");
if (jndiName != null) {
return lookupJndiDataSource(properties, context, jndiName);
}
return new HikariDataSource(new HikariConfig(properties));
}
private DataSource lookupJndiDataSource(final Properties properties, final Context context, final String jndiName) throws NamingException
{
if (context == null) {
throw new RuntimeException("JNDI context does not found for dataSourceJNDI : " + jndiName);
}
DataSource jndiDS = (DataSource) context.lookup(jndiName);
if (jndiDS == null) {
final Context ic = new InitialContext();
jndiDS = (DataSource) ic.lookup(jndiName);
ic.close();
}
if (jndiDS != null) {
HikariConfig config = new HikariConfig(properties);
config.setDataSource(jndiDS);
return new HikariDataSource(config);
}
return null;
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/HikariPoolMXBean.java 0000664 0000000 0000000 00000001721 13154316420 0026544 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari;
/**
* The javax.management MBean for a Hikari pool instance.
*
* @author Brett Wooldridge
*/
public interface HikariPoolMXBean
{
int getIdleConnections();
int getActiveConnections();
int getTotalConnections();
int getThreadsAwaitingConnection();
void softEvictConnections();
void suspendPool();
void resumePool();
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/hibernate/ 0000775 0000000 0000000 00000000000 13154316420 0024545 5 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/hibernate/HikariConfigurationUtil.java 0000664 0000000 0000000 00000004611 13154316420 0032207 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.hibernate;
import java.util.Map;
import java.util.Properties;
import org.hibernate.cfg.AvailableSettings;
import com.zaxxer.hikari.HikariConfig;
/**
* Utility class to map Hibernate properties to HikariCP configuration properties.
*
* @author Brett Wooldridge, Luca Burgazzoli
*/
public class HikariConfigurationUtil
{
public static final String CONFIG_PREFIX = "hibernate.hikari.";
public static final String CONFIG_PREFIX_DATASOURCE = "hibernate.hikari.dataSource.";
/**
* Create/load a HikariConfig from Hibernate properties.
*
* @param props a map of Hibernate properties
* @return a HikariConfig
*/
@SuppressWarnings("rawtypes")
public static HikariConfig loadConfiguration(Map props)
{
Properties hikariProps = new Properties();
copyProperty(AvailableSettings.ISOLATION, props, "transactionIsolation", hikariProps);
copyProperty(AvailableSettings.AUTOCOMMIT, props, "autoCommit", hikariProps);
copyProperty(AvailableSettings.DRIVER, props, "driverClassName", hikariProps);
copyProperty(AvailableSettings.URL, props, "jdbcUrl", hikariProps);
copyProperty(AvailableSettings.USER, props, "username", hikariProps);
copyProperty(AvailableSettings.PASS, props, "password", hikariProps);
for (Object keyo : props.keySet()) {
String key = (String) keyo;
if (key.startsWith(CONFIG_PREFIX)) {
hikariProps.setProperty(key.substring(CONFIG_PREFIX.length()), (String) props.get(key));
}
}
return new HikariConfig(hikariProps);
}
@SuppressWarnings("rawtypes")
private static void copyProperty(String srcKey, Map src, String dstKey, Properties dst)
{
if (src.containsKey(srcKey)) {
dst.setProperty(dstKey, (String) src.get(srcKey));
}
}
} HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/hibernate/HikariConnectionProvider.java 0000664 0000000 0000000 00000010602 13154316420 0032351 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.hibernate;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Map;
import org.hibernate.HibernateException;
import org.hibernate.Version;
import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
import org.hibernate.service.UnknownUnwrapTypeException;
import org.hibernate.service.spi.Configurable;
import org.hibernate.service.spi.Stoppable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;
/**
* Connection provider for Hibernate 4.3.
*
* @author Brett Wooldridge, Luca Burgazzoli
*/
public class HikariConnectionProvider implements ConnectionProvider, Configurable, Stoppable
{
private static final long serialVersionUID = -9131625057941275711L;
private static final Logger LOGGER = LoggerFactory.getLogger(HikariConnectionProvider.class);
/**
* HikariCP configuration.
*/
private HikariConfig hcfg;
/**
* HikariCP data source.
*/
private HikariDataSource hds;
// *************************************************************************
//
// *************************************************************************
/**
* c-tor
*/
public HikariConnectionProvider()
{
this.hcfg = null;
this.hds = null;
if (Version.getVersionString().substring(0, 5).compareTo("4.3.6") >= 1) {
LOGGER.warn("com.zaxxer.hikari.hibernate.HikariConnectionProvider has been deprecated for versions of "
+ "Hibernate 4.3.6 and newer. Please switch to org.hibernate.hikaricp.internal.HikariCPConnectionProvider.");
}
}
// *************************************************************************
// Configurable
// *************************************************************************
@SuppressWarnings("rawtypes")
@Override
public void configure(Map props) throws HibernateException
{
try {
LOGGER.debug("Configuring HikariCP");
this.hcfg = HikariConfigurationUtil.loadConfiguration(props);
this.hds = new HikariDataSource(this.hcfg);
}
catch (Exception e) {
throw new HibernateException(e);
}
LOGGER.debug("HikariCP Configured");
}
// *************************************************************************
// ConnectionProvider
// *************************************************************************
@Override
public Connection getConnection() throws SQLException
{
Connection conn = null;
if (this.hds != null) {
conn = this.hds.getConnection();
}
return conn;
}
@Override
public void closeConnection(Connection conn) throws SQLException
{
conn.close();
}
@Override
public boolean supportsAggressiveRelease()
{
return false;
}
@Override
@SuppressWarnings("rawtypes")
public boolean isUnwrappableAs(Class unwrapType)
{
return ConnectionProvider.class.equals(unwrapType) || HikariConnectionProvider.class.isAssignableFrom(unwrapType);
}
@Override
@SuppressWarnings("unchecked")
public T unwrap(Class unwrapType)
{
if ( ConnectionProvider.class.equals( unwrapType ) ||
HikariConnectionProvider.class.isAssignableFrom( unwrapType ) ) {
return (T) this;
}
else if ( DataSource.class.isAssignableFrom( unwrapType ) ) {
return (T) this.hds;
}
else {
throw new UnknownUnwrapTypeException( unwrapType );
}
}
// *************************************************************************
// Stoppable
// *************************************************************************
@Override
public void stop()
{
this.hds.close();
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/ 0000775 0000000 0000000 00000000000 13154316420 0024252 5 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/IMetricsTracker.java 0000664 0000000 0000000 00000002047 13154316420 0030153 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2017 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics;
/**
* @author Brett Wooldridge
*/
public interface IMetricsTracker extends AutoCloseable
{
default void recordConnectionCreatedMillis(long connectionCreatedMillis) {}
default void recordConnectionAcquiredNanos(final long elapsedAcquiredNanos) {}
default void recordConnectionUsageMillis(final long elapsedBorrowedMillis) {}
default void recordConnectionTimeout() {}
@Override
default void close() {}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/MetricsTracker.java 0000775 0000000 0000000 00000001456 13154316420 0030050 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013,2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics;
/**
* This class only supports realtime, not historical metrics.
*
* @author Brett Wooldridge
*/
@Deprecated
public class MetricsTracker implements IMetricsTracker
{
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/MetricsTrackerFactory.java 0000664 0000000 0000000 00000001710 13154316420 0031366 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013,2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics;
public interface MetricsTrackerFactory
{
/**
* Create an instance of an IMetricsTracker.
*
* @param poolName the name of the pool
* @param poolStats a PoolStats instance to use
* @return a IMetricsTracker implementation instance
*/
IMetricsTracker create(String poolName, PoolStats poolStats);
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/PoolStats.java 0000664 0000000 0000000 00000004205 13154316420 0027046 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2015 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics;
import static com.zaxxer.hikari.util.ClockSource.currentTime;
import static com.zaxxer.hikari.util.ClockSource.plusMillis;
import java.util.concurrent.atomic.AtomicLong;
/**
*
* @author Brett Wooldridge
*/
public abstract class PoolStats
{
private final AtomicLong reloadAt;
private final long timeoutMs;
protected volatile int totalConnections;
protected volatile int idleConnections;
protected volatile int activeConnections;
protected volatile int pendingThreads;
public PoolStats(final long timeoutMs)
{
this.timeoutMs = timeoutMs;
this.reloadAt = new AtomicLong();
}
public int getTotalConnections()
{
if (shouldLoad()) {
update();
}
return totalConnections;
}
public int getIdleConnections()
{
if (shouldLoad()) {
update();
}
return idleConnections;
}
public int getActiveConnections()
{
if (shouldLoad()) {
update();
}
return activeConnections;
}
public int getPendingThreads()
{
if (shouldLoad()) {
update();
}
return pendingThreads;
}
protected abstract void update();
private boolean shouldLoad()
{
for (; ; ) {
final long now = currentTime();
final long reloadTime = reloadAt.get();
if (reloadTime > now) {
return false;
}
else if (reloadAt.compareAndSet(reloadTime, plusMillis(now, timeoutMs))) {
return true;
}
}
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/dropwizard/ 0000775 0000000 0000000 00000000000 13154316420 0026437 5 ustar 00root root 0000000 0000000 CodaHaleMetricsTracker.java 0000775 0000000 0000000 00000013421 13154316420 0033532 0 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/dropwizard /*
* Copyright (C) 2013,2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics.dropwizard;
import java.util.concurrent.TimeUnit;
import com.codahale.metrics.Gauge;
import com.codahale.metrics.Histogram;
import com.codahale.metrics.Meter;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;
import com.zaxxer.hikari.metrics.IMetricsTracker;
import com.zaxxer.hikari.metrics.PoolStats;
public final class CodaHaleMetricsTracker implements IMetricsTracker
{
private final String poolName;
private final Timer connectionObtainTimer;
private final Histogram connectionUsage;
private final Histogram connectionCreation;
private final Meter connectionTimeoutMeter;
private final MetricRegistry registry;
private static final String METRIC_CATEGORY = "pool";
private static final String METRIC_NAME_WAIT = "Wait";
private static final String METRIC_NAME_USAGE = "Usage";
private static final String METRIC_NAME_CONNECT = "ConnectionCreation";
private static final String METRIC_NAME_TIMEOUT_RATE = "ConnectionTimeoutRate";
private static final String METRIC_NAME_TOTAL_CONNECTIONS = "TotalConnections";
private static final String METRIC_NAME_IDLE_CONNECTIONS = "IdleConnections";
private static final String METRIC_NAME_ACTIVE_CONNECTIONS = "ActiveConnections";
private static final String METRIC_NAME_PENDING_CONNECTIONS = "PendingConnections";
public CodaHaleMetricsTracker(final String poolName, final PoolStats poolStats, final MetricRegistry registry)
{
this.poolName = poolName;
this.registry = registry;
this.connectionObtainTimer = registry.timer(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_WAIT));
this.connectionUsage = registry.histogram(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_USAGE));
this.connectionCreation = registry.histogram(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_CONNECT));
this.connectionTimeoutMeter = registry.meter(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_TIMEOUT_RATE));
registry.register(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_TOTAL_CONNECTIONS),
new Gauge() {
@Override
public Integer getValue() {
return poolStats.getTotalConnections();
}
});
registry.register(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_IDLE_CONNECTIONS),
new Gauge() {
@Override
public Integer getValue() {
return poolStats.getIdleConnections();
}
});
registry.register(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_ACTIVE_CONNECTIONS),
new Gauge() {
@Override
public Integer getValue() {
return poolStats.getActiveConnections();
}
});
registry.register(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_PENDING_CONNECTIONS),
new Gauge() {
@Override
public Integer getValue() {
return poolStats.getPendingThreads();
}
});
}
/** {@inheritDoc} */
@Override
public void close()
{
registry.remove(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_WAIT));
registry.remove(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_USAGE));
registry.remove(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_CONNECT));
registry.remove(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_TIMEOUT_RATE));
registry.remove(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_TOTAL_CONNECTIONS));
registry.remove(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_IDLE_CONNECTIONS));
registry.remove(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_ACTIVE_CONNECTIONS));
registry.remove(MetricRegistry.name(poolName, METRIC_CATEGORY, METRIC_NAME_PENDING_CONNECTIONS));
}
/** {@inheritDoc} */
@Override
public void recordConnectionAcquiredNanos(final long elapsedAcquiredNanos)
{
connectionObtainTimer.update(elapsedAcquiredNanos, TimeUnit.NANOSECONDS);
}
/** {@inheritDoc} */
@Override
public void recordConnectionUsageMillis(final long elapsedBorrowedMillis)
{
connectionUsage.update(elapsedBorrowedMillis);
}
@Override
public void recordConnectionTimeout()
{
connectionTimeoutMeter.mark();
}
@Override
public void recordConnectionCreatedMillis(long connectionCreatedMillis)
{
connectionCreation.update(connectionCreatedMillis);
}
public Timer getConnectionAcquisitionTimer()
{
return connectionObtainTimer;
}
public Histogram getConnectionDurationHistogram()
{
return connectionUsage;
}
public Histogram getConnectionCreationHistogram()
{
return connectionCreation;
}
}
CodahaleHealthChecker.java 0000664 0000000 0000000 00000012132 13154316420 0033335 0 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/dropwizard /*
* Copyright (C) 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics.dropwizard;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import java.util.SortedMap;
import java.util.concurrent.TimeUnit;
import com.codahale.metrics.Metric;
import com.codahale.metrics.MetricFilter;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;
import com.codahale.metrics.health.HealthCheck;
import com.codahale.metrics.health.HealthCheckRegistry;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.pool.HikariPool;
/**
* Provides Dropwizard HealthChecks. Two health checks are provided:
*
*
ConnectivityCheck
*
Connection99Percent
*
* The ConnectivityCheck will use the connectionTimeout, unless the health check property
* connectivityCheckTimeoutMs is defined. However, if either the connectionTimeout
* or the connectivityCheckTimeoutMs is 0 (infinite), a timeout of 10 seconds will be used.
*
* The Connection99Percent health check will only be registered if the health check property
* expected99thPercentileMs is defined and greater than 0.
*
* @author Brett Wooldridge
*/
public final class CodahaleHealthChecker
{
/**
* Register Dropwizard health checks.
*
* @param pool the pool to register health checks for
* @param hikariConfig the pool configuration
* @param registry the HealthCheckRegistry into which checks will be registered
*/
public static void registerHealthChecks(final HikariPool pool, final HikariConfig hikariConfig, final HealthCheckRegistry registry)
{
final Properties healthCheckProperties = hikariConfig.getHealthCheckProperties();
final MetricRegistry metricRegistry = (MetricRegistry) hikariConfig.getMetricRegistry();
final long checkTimeoutMs = Long.parseLong(healthCheckProperties.getProperty("connectivityCheckTimeoutMs", String.valueOf(hikariConfig.getConnectionTimeout())));
registry.register(MetricRegistry.name(hikariConfig.getPoolName(), "pool", "ConnectivityCheck"), new ConnectivityHealthCheck(pool, checkTimeoutMs));
final long expected99thPercentile = Long.parseLong(healthCheckProperties.getProperty("expected99thPercentileMs", "0"));
if (metricRegistry != null && expected99thPercentile > 0) {
SortedMap timers = metricRegistry.getTimers(new MetricFilter() {
@Override
public boolean matches(String name, Metric metric)
{
return name.equals(MetricRegistry.name(hikariConfig.getPoolName(), "pool", "Wait"));
}
});
if (!timers.isEmpty()) {
final Timer timer = timers.entrySet().iterator().next().getValue();
registry.register(MetricRegistry.name(hikariConfig.getPoolName(), "pool", "Connection99Percent"), new Connection99Percent(timer, expected99thPercentile));
}
}
}
private CodahaleHealthChecker()
{
// private constructor
}
private static class ConnectivityHealthCheck extends HealthCheck
{
private final HikariPool pool;
private final long checkTimeoutMs;
ConnectivityHealthCheck(final HikariPool pool, final long checkTimeoutMs)
{
this.pool = pool;
this.checkTimeoutMs = (checkTimeoutMs > 0 && checkTimeoutMs != Integer.MAX_VALUE ? checkTimeoutMs : TimeUnit.SECONDS.toMillis(10));
}
/** {@inheritDoc} */
@Override
protected Result check() throws Exception
{
try (Connection connection = pool.getConnection(checkTimeoutMs)) {
return Result.healthy();
}
catch (SQLException e) {
return Result.unhealthy(e);
}
}
}
private static class Connection99Percent extends HealthCheck
{
private final Timer waitTimer;
private final long expected99thPercentile;
Connection99Percent(final Timer waitTimer, final long expected99thPercentile)
{
this.waitTimer = waitTimer;
this.expected99thPercentile = expected99thPercentile;
}
/** {@inheritDoc} */
@Override
protected Result check() throws Exception
{
final long the99thPercentile = TimeUnit.NANOSECONDS.toMillis(Math.round(waitTimer.getSnapshot().get99thPercentile()));
return the99thPercentile <= expected99thPercentile ? Result.healthy() : Result.unhealthy("99th percentile connection wait time of %dms exceeds the threshold %dms", the99thPercentile, expected99thPercentile);
}
}
}
CodahaleMetricsTrackerFactory.java 0000664 0000000 0000000 00000002447 13154316420 0035125 0 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/dropwizard /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics.dropwizard;
import com.codahale.metrics.MetricRegistry;
import com.zaxxer.hikari.metrics.IMetricsTracker;
import com.zaxxer.hikari.metrics.MetricsTrackerFactory;
import com.zaxxer.hikari.metrics.PoolStats;
public final class CodahaleMetricsTrackerFactory implements MetricsTrackerFactory
{
private final MetricRegistry registry;
public CodahaleMetricsTrackerFactory(MetricRegistry registry)
{
this.registry = registry;
}
public MetricRegistry getRegistry()
{
return registry;
}
@Override
public IMetricsTracker create(String poolName, PoolStats poolStats)
{
return new CodaHaleMetricsTracker(poolName, poolStats, registry);
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/micrometer/ 0000775 0000000 0000000 00000000000 13154316420 0026420 5 ustar 00root root 0000000 0000000 MicrometerMetricsTracker.java 0000664 0000000 0000000 00000011100 13154316420 0034146 0 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/micrometer package com.zaxxer.hikari.metrics.micrometer;
import com.zaxxer.hikari.metrics.IMetricsTracker;
import com.zaxxer.hikari.metrics.PoolStats;
import io.micrometer.core.instrument.DistributionSummary;
import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import io.micrometer.core.instrument.stats.quantile.WindowSketchQuantiles;
import java.util.concurrent.TimeUnit;
import static io.micrometer.core.instrument.stats.hist.CumulativeHistogram.buckets;
import static io.micrometer.core.instrument.stats.hist.CumulativeHistogram.linear;
public class MicrometerMetricsTracker implements IMetricsTracker
{
private static final String METRIC_CATEGORY = "pool";
private static final String METRIC_NAME_WAIT = "Wait";
private static final String METRIC_NAME_USAGE = "Usage";
private static final String METRIC_NAME_CONNECT = "ConnectionCreation";
private static final String METRIC_NAME_TIMEOUT_RATE = "ConnectionTimeoutRate";
private static final String METRIC_NAME_TOTAL_CONNECTIONS = "TotalConnections";
private static final String METRIC_NAME_IDLE_CONNECTIONS = "IdleConnections";
private static final String METRIC_NAME_ACTIVE_CONNECTIONS = "ActiveConnections";
private static final String METRIC_NAME_PENDING_CONNECTIONS = "PendingConnections";
private final Timer connectionObtainTimer;
private final DistributionSummary connectionTimeoutMeter;
private final DistributionSummary connectionUsage;
private final DistributionSummary connectionCreation;
@SuppressWarnings({"FieldCanBeLocal", "unused"})
private final Gauge totalConnectionGauge;
@SuppressWarnings({"FieldCanBeLocal", "unused"})
private final Gauge idleConnectionGauge;
@SuppressWarnings({"FieldCanBeLocal", "unused"})
private final Gauge activeConnectionGauge;
@SuppressWarnings({"FieldCanBeLocal", "unused"})
private final Gauge pendingConnectionGauge;
MicrometerMetricsTracker(final String poolName, final PoolStats poolStats, final MeterRegistry meterRegistry)
{
this.connectionObtainTimer = meterRegistry
.timerBuilder(METRIC_NAME_WAIT)
.tags(METRIC_CATEGORY, poolName)
.create();
this.connectionCreation = meterRegistry
.summaryBuilder(METRIC_NAME_CONNECT)
.tags(METRIC_CATEGORY, poolName)
.quantiles(WindowSketchQuantiles.quantiles(0.5, 0.95).create())
.histogram(buckets(linear(0, 10, 20), TimeUnit.MILLISECONDS))
.create();
this.connectionUsage = meterRegistry
.summaryBuilder(METRIC_NAME_USAGE)
.tags(METRIC_CATEGORY, poolName)
.quantiles(WindowSketchQuantiles.quantiles(0.5, 0.95).create())
.histogram(buckets(linear(0, 10, 20), TimeUnit.MILLISECONDS))
.create();
this.connectionTimeoutMeter = meterRegistry
.summaryBuilder(METRIC_NAME_TIMEOUT_RATE)
.tags(METRIC_CATEGORY, poolName)
.quantiles(WindowSketchQuantiles.quantiles(0.5, 0.95).create())
.histogram(buckets(linear(0, 10, 20), TimeUnit.MILLISECONDS))
.create();
this.totalConnectionGauge = meterRegistry
.gaugeBuilder(METRIC_NAME_TOTAL_CONNECTIONS, Integer.class, (i) -> poolStats.getTotalConnections())
.tags(METRIC_CATEGORY, poolName)
.create();
this.idleConnectionGauge = meterRegistry
.gaugeBuilder(METRIC_NAME_IDLE_CONNECTIONS, Integer.class, (i) -> poolStats.getIdleConnections())
.tags(METRIC_CATEGORY, poolName)
.create();
this.activeConnectionGauge = meterRegistry
.gaugeBuilder(METRIC_NAME_ACTIVE_CONNECTIONS, Integer.class, (i) -> poolStats.getActiveConnections())
.tags(METRIC_CATEGORY, poolName)
.create();
this.pendingConnectionGauge = meterRegistry
.gaugeBuilder(METRIC_NAME_PENDING_CONNECTIONS, Integer.class, (i) -> poolStats.getPendingThreads())
.tags(METRIC_CATEGORY, poolName)
.create();
}
/** {@inheritDoc} */
@Override
public void recordConnectionAcquiredNanos(final long elapsedAcquiredNanos)
{
connectionObtainTimer.record(elapsedAcquiredNanos, TimeUnit.NANOSECONDS);
}
/** {@inheritDoc} */
@Override
public void recordConnectionUsageMillis(final long elapsedBorrowedMillis)
{
connectionUsage.record(elapsedBorrowedMillis);
}
@Override
public void recordConnectionTimeout()
{
connectionTimeoutMeter.count();
}
@Override
public void recordConnectionCreatedMillis(long connectionCreatedMillis)
{
connectionCreation.record(connectionCreatedMillis);
}
}
MicrometerMetricsTrackerFactory.java 0000664 0000000 0000000 00000001214 13154316420 0035503 0 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/micrometer package com.zaxxer.hikari.metrics.micrometer;
import com.zaxxer.hikari.metrics.IMetricsTracker;
import com.zaxxer.hikari.metrics.MetricsTrackerFactory;
import com.zaxxer.hikari.metrics.PoolStats;
import io.micrometer.core.instrument.MeterRegistry;
public class MicrometerMetricsTrackerFactory implements MetricsTrackerFactory {
private final MeterRegistry registry;
public MicrometerMetricsTrackerFactory(MeterRegistry registry)
{
this.registry = registry;
}
@Override
public IMetricsTracker create(String poolName, PoolStats poolStats)
{
return new MicrometerMetricsTracker(poolName, poolStats, registry);
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/prometheus/ 0000775 0000000 0000000 00000000000 13154316420 0026445 5 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/prometheus/HikariCPCollector.java 0000664 0000000 0000000 00000004364 13154316420 0032620 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013, 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics.prometheus;
import com.zaxxer.hikari.metrics.PoolStats;
import io.prometheus.client.Collector;
import io.prometheus.client.GaugeMetricFamily;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
class HikariCPCollector extends Collector {
private static final List LABEL_NAMES = Collections.singletonList("pool");
private final Map poolStatsMap = new ConcurrentHashMap<>();
@Override
public List collect() {
return Arrays.asList(
createGauge("hikaricp_active_connections", "Active connections",
PoolStats::getActiveConnections),
createGauge("hikaricp_idle_connections", "Idle connections",
PoolStats::getIdleConnections),
createGauge("hikaricp_pending_threads", "Pending threads",
PoolStats::getPendingThreads),
createGauge("hikaricp_connections", "The number of current connections",
PoolStats::getTotalConnections)
);
}
protected HikariCPCollector add(String name, PoolStats poolStats) {
poolStatsMap.put(name, poolStats);
return this;
}
private GaugeMetricFamily createGauge(String metric, String help,
Function metricValueFunction) {
GaugeMetricFamily metricFamily = new GaugeMetricFamily(metric, help, LABEL_NAMES);
poolStatsMap.forEach((k, v) -> metricFamily.addMetric(
Collections.singletonList(k),
metricValueFunction.apply(v)
));
return metricFamily;
}
}
PrometheusMetricsTracker.java 0000664 0000000 0000000 00000005737 13154316420 0034243 0 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/prometheus /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics.prometheus;
import com.zaxxer.hikari.metrics.IMetricsTracker;
import io.prometheus.client.Collector;
import io.prometheus.client.CollectorRegistry;
import io.prometheus.client.Counter;
import io.prometheus.client.Summary;
import java.util.concurrent.TimeUnit;
class PrometheusMetricsTracker implements IMetricsTracker
{
private static final Counter CONNECTION_TIMEOUT_COUNTER = Counter.build()
.name("hikaricp_connection_timeout_total")
.labelNames("pool")
.help("Connection timeout total count")
.register();
private static final Summary ELAPSED_ACQUIRED_SUMMARY = Summary.build()
.name("hikaricp_connection_acquired_nanos")
.labelNames("pool")
.help("Connection acquired time (ns)")
.register();
private static final Summary ELAPSED_BORROWED_SUMMARY = Summary.build()
.name("hikaricp_connection_usage_millis")
.labelNames("pool")
.help("Connection usage (ms)")
.register();
private static final Summary ELAPSED_CREATION_SUMMARY = Summary.build()
.name("hikaricp_connection_creation_millis")
.labelNames("pool")
.help("Connection creation (ms)")
.register();
private final Counter.Child connectionTimeoutCounterChild;
private final Summary.Child elapsedAcquiredSummaryChild;
private final Summary.Child elapsedBorrowedSummaryChild;
private final Summary.Child elapsedCreationSummaryChild;
PrometheusMetricsTracker(String poolName) {
this.connectionTimeoutCounterChild = CONNECTION_TIMEOUT_COUNTER.labels(poolName);
this.elapsedAcquiredSummaryChild = ELAPSED_ACQUIRED_SUMMARY.labels(poolName);
this.elapsedBorrowedSummaryChild = ELAPSED_BORROWED_SUMMARY.labels(poolName);
this.elapsedCreationSummaryChild = ELAPSED_CREATION_SUMMARY.labels(poolName);
}
@Override
public void recordConnectionAcquiredNanos(long elapsedAcquiredNanos)
{
elapsedAcquiredSummaryChild.observe(elapsedAcquiredNanos);
}
@Override
public void recordConnectionUsageMillis(long elapsedBorrowedMillis)
{
elapsedBorrowedSummaryChild.observe(elapsedBorrowedMillis);
}
@Override
public void recordConnectionCreatedMillis(long connectionCreatedMillis)
{
elapsedCreationSummaryChild.observe(connectionCreatedMillis);
}
@Override
public void recordConnectionTimeout()
{
connectionTimeoutCounterChild.inc();
}
}
PrometheusMetricsTrackerFactory.java 0000664 0000000 0000000 00000002770 13154316420 0035565 0 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/metrics/prometheus /*
* Copyright (C) 2016 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.metrics.prometheus;
import com.zaxxer.hikari.metrics.IMetricsTracker;
import com.zaxxer.hikari.metrics.MetricsTrackerFactory;
import com.zaxxer.hikari.metrics.PoolStats;
/**
*
*/
public class PrometheusMetricsTrackerFactory implements MetricsTrackerFactory {
private static HikariCPCollector collector;
@Override
public IMetricsTracker create(String poolName, PoolStats poolStats) {
getCollector().add(poolName, poolStats);
return new PrometheusMetricsTracker(poolName);
}
/**
* initialize and register collector if it isn't initialized yet
*/
private HikariCPCollector getCollector() {
if (collector == null) {
collector = new HikariCPCollector().register();
}
return collector;
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/ 0000775 0000000 0000000 00000000000 13154316420 0023555 5 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/HikariPool.java 0000775 0000000 0000000 00000064341 13154316420 0026474 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013,2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import static com.zaxxer.hikari.util.ClockSource.currentTime;
import static com.zaxxer.hikari.util.ClockSource.elapsedDisplayString;
import static com.zaxxer.hikari.util.ClockSource.elapsedMillis;
import static com.zaxxer.hikari.util.ClockSource.plusMillis;
import static com.zaxxer.hikari.util.ConcurrentBag.IConcurrentBagEntry.STATE_IN_USE;
import static com.zaxxer.hikari.util.ConcurrentBag.IConcurrentBagEntry.STATE_NOT_IN_USE;
import static com.zaxxer.hikari.util.UtilityElf.createThreadPoolExecutor;
import static com.zaxxer.hikari.util.UtilityElf.quietlySleep;
import static java.util.Collections.unmodifiableCollection;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLTransientConnectionException;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.ThreadPoolExecutor;
import com.zaxxer.hikari.metrics.micrometer.MicrometerMetricsTrackerFactory;
import io.micrometer.core.instrument.MeterRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.health.HealthCheckRegistry;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariPoolMXBean;
import com.zaxxer.hikari.metrics.MetricsTrackerFactory;
import com.zaxxer.hikari.metrics.PoolStats;
import com.zaxxer.hikari.metrics.dropwizard.CodahaleHealthChecker;
import com.zaxxer.hikari.metrics.dropwizard.CodahaleMetricsTrackerFactory;
import com.zaxxer.hikari.util.ConcurrentBag;
import com.zaxxer.hikari.util.ConcurrentBag.IBagStateListener;
import com.zaxxer.hikari.util.SuspendResumeLock;
import com.zaxxer.hikari.util.UtilityElf.DefaultThreadFactory;
/**
* This is the primary connection pool class that provides the basic
* pooling behavior for HikariCP.
*
* @author Brett Wooldridge
*/
public final class HikariPool extends PoolBase implements HikariPoolMXBean, IBagStateListener
{
private final Logger LOGGER = LoggerFactory.getLogger(HikariPool.class);
private static final int POOL_NORMAL = 0;
private static final int POOL_SUSPENDED = 1;
private static final int POOL_SHUTDOWN = 2;
private volatile int poolState;
private final long ALIVE_BYPASS_WINDOW_MS = Long.getLong("com.zaxxer.hikari.aliveBypassWindowMs", MILLISECONDS.toMillis(500));
private final long HOUSEKEEPING_PERIOD_MS = Long.getLong("com.zaxxer.hikari.housekeeping.periodMs", SECONDS.toMillis(30));
private final PoolEntryCreator POOL_ENTRY_CREATOR = new PoolEntryCreator(null);
private final PoolEntryCreator POST_FILL_POOL_ENTRY_CREATOR = new PoolEntryCreator("After adding ");
private final Collection addConnectionQueue;
private final ThreadPoolExecutor addConnectionExecutor;
private final ThreadPoolExecutor closeConnectionExecutor;
private final ConcurrentBag connectionBag;
private final ProxyLeakTaskFactory leakTaskFactory;
private final SuspendResumeLock suspendResumeLock;
private ScheduledExecutorService houseKeepingExecutorService;
private ScheduledFuture houseKeeperTask;
/**
* Construct a HikariPool with the specified configuration.
*
* @param config a HikariConfig instance
*/
public HikariPool(final HikariConfig config)
{
super(config);
this.connectionBag = new ConcurrentBag<>(this);
this.suspendResumeLock = config.isAllowPoolSuspension() ? new SuspendResumeLock() : SuspendResumeLock.FAUX_LOCK;
this.houseKeepingExecutorService = initializeHouseKeepingExecutorService();
checkFailFast();
if (config.getMetricsTrackerFactory() != null) {
setMetricsTrackerFactory(config.getMetricsTrackerFactory());
}
else {
setMetricRegistry(config.getMetricRegistry());
}
setHealthCheckRegistry(config.getHealthCheckRegistry());
registerMBeans(this);
ThreadFactory threadFactory = config.getThreadFactory();
LinkedBlockingQueue addConnectionQueue = new LinkedBlockingQueue<>(config.getMaximumPoolSize());
this.addConnectionQueue = unmodifiableCollection(addConnectionQueue);
this.addConnectionExecutor = createThreadPoolExecutor(addConnectionQueue, poolName + " connection adder", threadFactory, new ThreadPoolExecutor.DiscardPolicy());
this.closeConnectionExecutor = createThreadPoolExecutor(config.getMaximumPoolSize(), poolName + " connection closer", threadFactory, new ThreadPoolExecutor.CallerRunsPolicy());
this.leakTaskFactory = new ProxyLeakTaskFactory(config.getLeakDetectionThreshold(), houseKeepingExecutorService);
this.houseKeeperTask = houseKeepingExecutorService.scheduleWithFixedDelay(new HouseKeeper(), 100L, HOUSEKEEPING_PERIOD_MS, MILLISECONDS);
}
/**
* Get a connection from the pool, or timeout after connectionTimeout milliseconds.
*
* @return a java.sql.Connection instance
* @throws SQLException thrown if a timeout occurs trying to obtain a connection
*/
public Connection getConnection() throws SQLException
{
return getConnection(connectionTimeout);
}
/**
* Get a connection from the pool, or timeout after the specified number of milliseconds.
*
* @param hardTimeout the maximum time to wait for a connection from the pool
* @return a java.sql.Connection instance
* @throws SQLException thrown if a timeout occurs trying to obtain a connection
*/
public Connection getConnection(final long hardTimeout) throws SQLException
{
suspendResumeLock.acquire();
final long startTime = currentTime();
try {
long timeout = hardTimeout;
PoolEntry poolEntry = null;
try {
do {
poolEntry = connectionBag.borrow(timeout, MILLISECONDS);
if (poolEntry == null) {
break; // We timed out... break and throw exception
}
final long now = currentTime();
if (poolEntry.isMarkedEvicted() || (elapsedMillis(poolEntry.lastAccessed, now) > ALIVE_BYPASS_WINDOW_MS && !isConnectionAlive(poolEntry.connection))) {
closeConnection(poolEntry, "(connection is evicted or dead)"); // Throw away the dead connection (passed max age or failed alive test)
timeout = hardTimeout - elapsedMillis(startTime);
}
else {
metricsTracker.recordBorrowStats(poolEntry, startTime);
return poolEntry.createProxyConnection(leakTaskFactory.schedule(poolEntry), now);
}
} while (timeout > 0L);
metricsTracker.recordBorrowTimeoutStats(startTime);
}
catch (InterruptedException e) {
if (poolEntry != null) {
poolEntry.recycle(startTime);
}
Thread.currentThread().interrupt();
throw new SQLException(poolName + " - Interrupted during connection acquisition", e);
}
}
finally {
suspendResumeLock.release();
}
throw createTimeoutException(startTime);
}
/**
* Shutdown the pool, closing all idle connections and aborting or closing
* active connections.
*
* @throws InterruptedException thrown if the thread is interrupted during shutdown
*/
public synchronized void shutdown() throws InterruptedException
{
try {
poolState = POOL_SHUTDOWN;
if (addConnectionExecutor == null) {
return;
}
logPoolState("Before shutdown ");
if (houseKeeperTask != null) {
houseKeeperTask.cancel(false);
houseKeeperTask = null;
}
softEvictConnections();
addConnectionExecutor.shutdown();
addConnectionExecutor.awaitTermination(getLoginTimeout(), SECONDS);
destroyHouseKeepingExecutorService();
connectionBag.close();
final ExecutorService assassinExecutor = createThreadPoolExecutor(config.getMaximumPoolSize(), poolName + " connection assassinator",
config.getThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
try {
final long start = currentTime();
do {
abortActiveConnections(assassinExecutor);
softEvictConnections();
} while (getTotalConnections() > 0 && elapsedMillis(start) < SECONDS.toMillis(10));
}
finally {
assassinExecutor.shutdown();
assassinExecutor.awaitTermination(10L, SECONDS);
}
shutdownNetworkTimeoutExecutor();
closeConnectionExecutor.shutdown();
closeConnectionExecutor.awaitTermination(10L, SECONDS);
}
finally {
logPoolState("After shutdown ");
unregisterMBeans();
metricsTracker.close();
}
}
/**
* Evict a connection from the pool.
*
* @param connection the connection to evict
*/
public void evictConnection(Connection connection)
{
ProxyConnection proxyConnection = (ProxyConnection) connection;
proxyConnection.cancelLeakTask();
try {
softEvictConnection(proxyConnection.getPoolEntry(), "(connection evicted by user)", !connection.isClosed() /* owner */);
}
catch (SQLException e) {
// unreachable in HikariCP, but we're still forced to catch it
}
}
public void setMetricRegistry(Object metricRegistry)
{
if (metricRegistry instanceof MetricRegistry) {
setMetricsTrackerFactory(new CodahaleMetricsTrackerFactory((MetricRegistry) metricRegistry));
}
else if (metricRegistry instanceof MeterRegistry) {
setMetricsTrackerFactory(new MicrometerMetricsTrackerFactory((MeterRegistry) metricRegistry));
}
else {
setMetricsTrackerFactory(null);
}
}
public void setMetricsTrackerFactory(MetricsTrackerFactory metricsTrackerFactory)
{
if (metricsTrackerFactory != null) {
this.metricsTracker = new MetricsTrackerDelegate(metricsTrackerFactory.create(config.getPoolName(), getPoolStats()));
}
else {
this.metricsTracker = new NopMetricsTrackerDelegate();
}
}
public void setHealthCheckRegistry(Object healthCheckRegistry)
{
if (healthCheckRegistry != null) {
CodahaleHealthChecker.registerHealthChecks(this, config, (HealthCheckRegistry) healthCheckRegistry);
}
}
// ***********************************************************************
// IBagStateListener callback
// ***********************************************************************
/** {@inheritDoc} */
@Override
public void addBagItem(final int waiting)
{
final boolean shouldAdd = waiting - addConnectionQueue.size() >= 0; // Yes, >= is intentional.
if (shouldAdd) {
addConnectionExecutor.submit(POOL_ENTRY_CREATOR);
}
CompletableFuture.completedFuture(Boolean.TRUE);
}
// ***********************************************************************
// HikariPoolMBean methods
// ***********************************************************************
/** {@inheritDoc} */
@Override
public int getActiveConnections()
{
return connectionBag.getCount(STATE_IN_USE);
}
/** {@inheritDoc} */
@Override
public int getIdleConnections()
{
return connectionBag.getCount(STATE_NOT_IN_USE);
}
/** {@inheritDoc} */
@Override
public int getTotalConnections()
{
return connectionBag.size();
}
/** {@inheritDoc} */
@Override
public int getThreadsAwaitingConnection()
{
return connectionBag.getWaitingThreadCount();
}
/** {@inheritDoc} */
@Override
public void softEvictConnections()
{
connectionBag.values().forEach(poolEntry -> softEvictConnection(poolEntry, "(connection evicted)", false /* not owner */));
}
/** {@inheritDoc} */
@Override
public synchronized void suspendPool()
{
if (suspendResumeLock == SuspendResumeLock.FAUX_LOCK) {
throw new IllegalStateException(poolName + " - is not suspendable");
}
else if (poolState != POOL_SUSPENDED) {
suspendResumeLock.suspend();
poolState = POOL_SUSPENDED;
}
}
/** {@inheritDoc} */
@Override
public synchronized void resumePool()
{
if (poolState == POOL_SUSPENDED) {
poolState = POOL_NORMAL;
fillPool();
suspendResumeLock.resume();
}
}
// ***********************************************************************
// Package methods
// ***********************************************************************
/**
* Log the current pool state at debug level.
*
* @param prefix an optional prefix to prepend the log message
*/
void logPoolState(String... prefix)
{
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("{} - {}stats (total={}, active={}, idle={}, waiting={})",
poolName, (prefix.length > 0 ? prefix[0] : ""),
getTotalConnections(), getActiveConnections(), getIdleConnections(), getThreadsAwaitingConnection());
}
}
/**
* Recycle PoolEntry (add back to the pool)
*
* @param poolEntry the PoolEntry to recycle
*/
@Override
void recycle(final PoolEntry poolEntry)
{
metricsTracker.recordConnectionUsage(poolEntry);
connectionBag.requite(poolEntry);
}
/**
* Permanently close the real (underlying) connection (eat any exception).
*
* @param poolEntry poolEntry having the connection to close
* @param closureReason reason to close
*/
void closeConnection(final PoolEntry poolEntry, final String closureReason)
{
if (connectionBag.remove(poolEntry)) {
final Connection connection = poolEntry.close();
closeConnectionExecutor.execute(() -> {
quietlyCloseConnection(connection, closureReason);
if (poolState == POOL_NORMAL) {
fillPool();
}
});
}
}
@SuppressWarnings("unused")
int[] getPoolStateCounts()
{
return connectionBag.getStateCounts();
}
// ***********************************************************************
// Private methods
// ***********************************************************************
/**
* Creating new poolEntry.
*/
private PoolEntry createPoolEntry()
{
try {
final PoolEntry poolEntry = newPoolEntry();
final long maxLifetime = config.getMaxLifetime();
if (maxLifetime > 0) {
// variance up to 2.5% of the maxlifetime
final long variance = maxLifetime > 10_000 ? ThreadLocalRandom.current().nextLong( maxLifetime / 40 ) : 0;
final long lifetime = maxLifetime - variance;
poolEntry.setFutureEol(houseKeepingExecutorService.schedule(
() -> {
if (softEvictConnection(poolEntry, "(connection has passed maxLifetime)", false /* not owner */)) {
addBagItem(connectionBag.getWaitingThreadCount());
}
},
lifetime, MILLISECONDS));
}
return poolEntry;
}
catch (Exception e) {
if (poolState == POOL_NORMAL) {
LOGGER.debug("{} - Cannot acquire connection from data source", poolName, (e instanceof ConnectionSetupException ? e.getCause() : e));
}
return null;
}
}
/**
* Fill pool up from current idle connections (as they are perceived at the point of execution) to minimumIdle connections.
*/
private synchronized void fillPool()
{
final int connectionsToAdd = Math.min(config.getMaximumPoolSize() - getTotalConnections(), config.getMinimumIdle() - getIdleConnections())
- addConnectionQueue.size();
for (int i = 0; i < connectionsToAdd; i++) {
addConnectionExecutor.submit((i < connectionsToAdd - 1) ? POOL_ENTRY_CREATOR : POST_FILL_POOL_ENTRY_CREATOR);
}
}
/**
* Attempt to abort or close active connections.
*/
private void abortActiveConnections(final ExecutorService assassinExecutor)
{
for (PoolEntry poolEntry : connectionBag.values(STATE_IN_USE)) {
Connection connection = poolEntry.close();
try {
connection.abort(assassinExecutor);
}
catch (Throwable e) {
quietlyCloseConnection(connection, "(connection aborted during shutdown)");
}
finally {
connectionBag.remove(poolEntry);
}
}
}
/**
* If initializationFailFast is configured, check that we have DB connectivity.
*
* @throws PoolInitializationException if fails to create or validate connection
*/
private void checkFailFast()
{
final long initializationTimeout = config.getInitializationFailTimeout();
if (initializationTimeout < 0) {
return;
}
final long startTime = currentTime();
do {
final PoolEntry poolEntry = createPoolEntry();
if (poolEntry != null) {
if (config.getMinimumIdle() > 0) {
connectionBag.add(poolEntry);
LOGGER.debug("{} - Added connection {}", poolName, poolEntry.connection);
}
else {
quietlyCloseConnection(poolEntry.close(), "(initialization check complete and minimumIdle is zero)");
}
return;
}
if (getLastConnectionFailure() instanceof ConnectionSetupException) {
throwPoolInitializationException(getLastConnectionFailure().getCause());
}
quietlySleep(1000L);
} while (elapsedMillis(startTime) < initializationTimeout);
if (initializationTimeout > 0) {
throwPoolInitializationException(getLastConnectionFailure());
}
}
private void throwPoolInitializationException(Throwable t)
{
LOGGER.error("{} - Exception during pool initialization.", poolName, t);
destroyHouseKeepingExecutorService();
throw new PoolInitializationException(t);
}
private boolean softEvictConnection(final PoolEntry poolEntry, final String reason, final boolean owner)
{
poolEntry.markEvicted();
if (owner || connectionBag.reserve(poolEntry)) {
closeConnection(poolEntry, reason);
return true;
}
return false;
}
private ScheduledExecutorService initializeHouseKeepingExecutorService()
{
if (config.getScheduledExecutor() == null) {
final ThreadFactory threadFactory = Optional.ofNullable(config.getThreadFactory()).orElse(new DefaultThreadFactory(poolName + " housekeeper", true));
final ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1, threadFactory, new ThreadPoolExecutor.DiscardPolicy());
executor.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
executor.setRemoveOnCancelPolicy(true);
return executor;
}
else {
return config.getScheduledExecutor();
}
}
private void destroyHouseKeepingExecutorService()
{
if (config.getScheduledExecutor() == null) {
houseKeepingExecutorService.shutdownNow();
}
}
private PoolStats getPoolStats()
{
return new PoolStats(SECONDS.toMillis(1)) {
@Override
protected void update() {
this.pendingThreads = HikariPool.this.getThreadsAwaitingConnection();
this.idleConnections = HikariPool.this.getIdleConnections();
this.totalConnections = HikariPool.this.getTotalConnections();
this.activeConnections = HikariPool.this.getActiveConnections();
}
};
}
private SQLException createTimeoutException(long startTime)
{
logPoolState("Timeout failure ");
metricsTracker.recordConnectionTimeout();
String sqlState = null;
final Throwable originalException = getLastConnectionFailure();
if (originalException instanceof SQLException) {
sqlState = ((SQLException) originalException).getSQLState();
}
final SQLException connectionException = new SQLTransientConnectionException(poolName + " - Connection is not available, request timed out after " + elapsedMillis(startTime) + "ms.", sqlState, originalException);
if (originalException instanceof SQLException) {
connectionException.setNextException((SQLException) originalException);
}
return connectionException;
}
// ***********************************************************************
// Non-anonymous Inner-classes
// ***********************************************************************
/**
* Creating and adding poolEntries (connections) to the pool.
*/
private final class PoolEntryCreator implements Callable
{
private final String loggingPrefix;
PoolEntryCreator(String loggingPrefix)
{
this.loggingPrefix = loggingPrefix;
}
@Override
public Boolean call() throws Exception
{
long sleepBackoff = 250L;
while (poolState == POOL_NORMAL && shouldCreateAnotherConnection()) {
final PoolEntry poolEntry = createPoolEntry();
if (poolEntry != null) {
connectionBag.add(poolEntry);
LOGGER.debug("{} - Added connection {}", poolName, poolEntry.connection);
if (loggingPrefix != null) {
logPoolState(loggingPrefix);
}
return Boolean.TRUE;
}
// failed to get connection from db, sleep and retry
quietlySleep(sleepBackoff);
sleepBackoff = Math.min(SECONDS.toMillis(10), Math.min(connectionTimeout, (long) (sleepBackoff * 1.5)));
}
// Pool is suspended or shutdown or at max size
return Boolean.FALSE;
}
private boolean shouldCreateAnotherConnection() {
// only create connections if we need another idle connection or have threads still waiting
// for a new connection, otherwise bail
return getTotalConnections() < config.getMaximumPoolSize() &&
(connectionBag.getWaitingThreadCount() > 0 || getIdleConnections() < config.getMinimumIdle());
}
}
/**
* The house keeping task to retire and maintain minimum idle connections.
*/
private final class HouseKeeper implements Runnable
{
private volatile long previous = plusMillis(currentTime(), -HOUSEKEEPING_PERIOD_MS);
@Override
public void run()
{
try {
// refresh timeouts in case they changed via MBean
connectionTimeout = config.getConnectionTimeout();
validationTimeout = config.getValidationTimeout();
leakTaskFactory.updateLeakDetectionThreshold(config.getLeakDetectionThreshold());
final long idleTimeout = config.getIdleTimeout();
final long now = currentTime();
// Detect retrograde time, allowing +128ms as per NTP spec.
if (plusMillis(now, 128) < plusMillis(previous, HOUSEKEEPING_PERIOD_MS)) {
LOGGER.warn("{} - Retrograde clock change detected (housekeeper delta={}), soft-evicting connections from pool.",
poolName, elapsedDisplayString(previous, now));
previous = now;
softEvictConnections();
fillPool();
return;
}
else if (now > plusMillis(previous, (3 * HOUSEKEEPING_PERIOD_MS) / 2)) {
// No point evicting for forward clock motion, this merely accelerates connection retirement anyway
LOGGER.warn("{} - Thread starvation or clock leap detected (housekeeper delta={}).", poolName, elapsedDisplayString(previous, now));
}
previous = now;
String afterPrefix = "Pool ";
if (idleTimeout > 0L && config.getMinimumIdle() < config.getMaximumPoolSize()) {
logPoolState("Before cleanup ");
afterPrefix = "After cleanup ";
final List notInUse = connectionBag.values(STATE_NOT_IN_USE);
int removed = 0;
for (PoolEntry entry : notInUse) {
if (elapsedMillis(entry.lastAccessed, now) > idleTimeout && connectionBag.reserve(entry)) {
closeConnection(entry, "(connection has passed idleTimeout)");
if (++removed > config.getMinimumIdle()) {
break;
}
}
}
}
logPoolState(afterPrefix);
fillPool(); // Try to maintain minimum connections
}
catch (Exception e) {
LOGGER.error("Unexpected exception in housekeeping task", e);
}
}
}
public static class PoolInitializationException extends RuntimeException
{
private static final long serialVersionUID = 929872118275916520L;
/**
* Construct an exception, possibly wrapping the provided Throwable as the cause.
* @param t the Throwable to wrap
*/
public PoolInitializationException(Throwable t)
{
super("Failed to initialize pool: " + t.getMessage(), t);
}
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/PoolBase.java 0000775 0000000 0000000 00000062550 13154316420 0026137 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013, 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import static com.zaxxer.hikari.pool.ProxyConnection.DIRTY_BIT_SCHEMA;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
import java.lang.management.ManagementFactory;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLTransientConnectionException;
import java.sql.Statement;
import java.util.Properties;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import com.zaxxer.hikari.pool.HikariPool.PoolInitializationException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.metrics.IMetricsTracker;
import com.zaxxer.hikari.util.DriverDataSource;
import com.zaxxer.hikari.util.PropertyElf;
import com.zaxxer.hikari.util.UtilityElf;
import com.zaxxer.hikari.util.UtilityElf.DefaultThreadFactory;
import static com.zaxxer.hikari.pool.ProxyConnection.DIRTY_BIT_AUTOCOMMIT;
import static com.zaxxer.hikari.pool.ProxyConnection.DIRTY_BIT_CATALOG;
import static com.zaxxer.hikari.pool.ProxyConnection.DIRTY_BIT_ISOLATION;
import static com.zaxxer.hikari.pool.ProxyConnection.DIRTY_BIT_NETTIMEOUT;
import static com.zaxxer.hikari.pool.ProxyConnection.DIRTY_BIT_READONLY;
import static com.zaxxer.hikari.util.ClockSource.currentTime;
import static com.zaxxer.hikari.util.ClockSource.elapsedMillis;
import static com.zaxxer.hikari.util.ClockSource.elapsedNanos;
import static com.zaxxer.hikari.util.UtilityElf.createInstance;
abstract class PoolBase
{
private final Logger LOGGER = LoggerFactory.getLogger(PoolBase.class);
protected final HikariConfig config;
protected final String poolName;
long connectionTimeout;
long validationTimeout;
IMetricsTrackerDelegate metricsTracker;
private static final String[] RESET_STATES = {"readOnly", "autoCommit", "isolation", "catalog", "netTimeout", "schema"};
private static final int UNINITIALIZED = -1;
private static final int TRUE = 1;
private static final int FALSE = 0;
private int networkTimeout;
private int isNetworkTimeoutSupported;
private int isQueryTimeoutSupported;
private int defaultTransactionIsolation;
private int transactionIsolation;
private Executor netTimeoutExecutor;
private DataSource dataSource;
private final String catalog;
private final String schema;
private final boolean isReadOnly;
private final boolean isAutoCommit;
private final boolean isUseJdbc4Validation;
private final boolean isIsolateInternalQueries;
private final AtomicReference lastConnectionFailure;
private volatile boolean isValidChecked;
PoolBase(final HikariConfig config)
{
this.config = config;
this.networkTimeout = UNINITIALIZED;
this.catalog = config.getCatalog();
this.schema = config.getSchema();
this.isReadOnly = config.isReadOnly();
this.isAutoCommit = config.isAutoCommit();
this.transactionIsolation = UtilityElf.getTransactionIsolation(config.getTransactionIsolation());
this.isQueryTimeoutSupported = UNINITIALIZED;
this.isNetworkTimeoutSupported = UNINITIALIZED;
this.isUseJdbc4Validation = config.getConnectionTestQuery() == null;
this.isIsolateInternalQueries = config.isIsolateInternalQueries();
this.poolName = config.getPoolName();
this.connectionTimeout = config.getConnectionTimeout();
this.validationTimeout = config.getValidationTimeout();
this.lastConnectionFailure = new AtomicReference<>();
initializeDataSource();
}
/** {@inheritDoc} */
@Override
public String toString()
{
return poolName;
}
abstract void recycle(final PoolEntry poolEntry);
// ***********************************************************************
// JDBC methods
// ***********************************************************************
void quietlyCloseConnection(final Connection connection, final String closureReason)
{
if (connection != null) {
try {
LOGGER.debug("{} - Closing connection {}: {}", poolName, connection, closureReason);
try {
setNetworkTimeout(connection, SECONDS.toMillis(15));
}
finally {
connection.close(); // continue with the close even if setNetworkTimeout() throws
}
}
catch (Throwable e) {
LOGGER.debug("{} - Closing connection {} failed", poolName, connection, e);
}
}
}
boolean isConnectionAlive(final Connection connection)
{
try {
try {
setNetworkTimeout(connection, validationTimeout);
final long validationSeconds = (int) Math.max(1000L, validationTimeout) / 1000;
if (isUseJdbc4Validation) {
return connection.isValid((int) validationSeconds);
}
try (Statement statement = connection.createStatement()) {
if (isNetworkTimeoutSupported != TRUE) {
setQueryTimeout(statement, (int) validationSeconds);
}
statement.execute(config.getConnectionTestQuery());
}
}
finally {
setNetworkTimeout(connection, networkTimeout);
if (isIsolateInternalQueries && !isAutoCommit) {
connection.rollback();
}
}
return true;
}
catch (Exception e) {
lastConnectionFailure.set(e);
LOGGER.warn("{} - Failed to validate connection {} ({})", poolName, connection, e.getMessage());
return false;
}
}
Throwable getLastConnectionFailure()
{
return lastConnectionFailure.get();
}
public DataSource getUnwrappedDataSource()
{
return dataSource;
}
// ***********************************************************************
// PoolEntry methods
// ***********************************************************************
PoolEntry newPoolEntry() throws Exception
{
return new PoolEntry(newConnection(), this, isReadOnly, isAutoCommit);
}
void resetConnectionState(final Connection connection, final ProxyConnection proxyConnection, final int dirtyBits) throws SQLException
{
int resetBits = 0;
if ((dirtyBits & DIRTY_BIT_READONLY) != 0 && proxyConnection.getReadOnlyState() != isReadOnly) {
connection.setReadOnly(isReadOnly);
resetBits |= DIRTY_BIT_READONLY;
}
if ((dirtyBits & DIRTY_BIT_AUTOCOMMIT) != 0 && proxyConnection.getAutoCommitState() != isAutoCommit) {
connection.setAutoCommit(isAutoCommit);
resetBits |= DIRTY_BIT_AUTOCOMMIT;
}
if ((dirtyBits & DIRTY_BIT_ISOLATION) != 0 && proxyConnection.getTransactionIsolationState() != transactionIsolation) {
connection.setTransactionIsolation(transactionIsolation);
resetBits |= DIRTY_BIT_ISOLATION;
}
if ((dirtyBits & DIRTY_BIT_CATALOG) != 0 && catalog != null && !catalog.equals(proxyConnection.getCatalogState())) {
connection.setCatalog(catalog);
resetBits |= DIRTY_BIT_CATALOG;
}
if ((dirtyBits & DIRTY_BIT_NETTIMEOUT) != 0 && proxyConnection.getNetworkTimeoutState() != networkTimeout) {
setNetworkTimeout(connection, networkTimeout);
resetBits |= DIRTY_BIT_NETTIMEOUT;
}
if ((dirtyBits & DIRTY_BIT_SCHEMA) != 0 && schema != null && !schema.equals(proxyConnection.getSchemaState())) {
connection.setSchema(schema);
resetBits |= DIRTY_BIT_SCHEMA;
}
if (resetBits != 0 && LOGGER.isDebugEnabled()) {
LOGGER.debug("{} - Reset ({}) on connection {}", poolName, stringFromResetBits(resetBits), connection);
}
}
void shutdownNetworkTimeoutExecutor()
{
if (netTimeoutExecutor instanceof ThreadPoolExecutor) {
((ThreadPoolExecutor) netTimeoutExecutor).shutdownNow();
}
}
long getLoginTimeout()
{
try {
return (dataSource != null) ? dataSource.getLoginTimeout() : SECONDS.toSeconds(5);
} catch (SQLException e) {
return SECONDS.toSeconds(5);
}
}
// ***********************************************************************
// JMX methods
// ***********************************************************************
/**
* Register MBeans for HikariConfig and HikariPool.
*
* @param hikariPool a HikariPool instance
*/
void registerMBeans(final HikariPool hikariPool)
{
if (!config.isRegisterMbeans()) {
return;
}
try {
final MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
final ObjectName beanConfigName = new ObjectName("com.zaxxer.hikari:type=PoolConfig (" + poolName + ")");
final ObjectName beanPoolName = new ObjectName("com.zaxxer.hikari:type=Pool (" + poolName + ")");
if (!mBeanServer.isRegistered(beanConfigName)) {
mBeanServer.registerMBean(config, beanConfigName);
mBeanServer.registerMBean(hikariPool, beanPoolName);
}
else {
LOGGER.error("{} - JMX name ({}) is already registered.", poolName, poolName);
}
}
catch (Exception e) {
LOGGER.warn("{} - Failed to register management beans.", poolName, e);
}
}
/**
* Unregister MBeans for HikariConfig and HikariPool.
*/
void unregisterMBeans()
{
if (!config.isRegisterMbeans()) {
return;
}
try {
final MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
final ObjectName beanConfigName = new ObjectName("com.zaxxer.hikari:type=PoolConfig (" + poolName + ")");
final ObjectName beanPoolName = new ObjectName("com.zaxxer.hikari:type=Pool (" + poolName + ")");
if (mBeanServer.isRegistered(beanConfigName)) {
mBeanServer.unregisterMBean(beanConfigName);
mBeanServer.unregisterMBean(beanPoolName);
}
}
catch (Exception e) {
LOGGER.warn("{} - Failed to unregister management beans.", poolName, e);
}
}
// ***********************************************************************
// Private methods
// ***********************************************************************
/**
* Create/initialize the underlying DataSource.
*/
private void initializeDataSource()
{
final String jdbcUrl = config.getJdbcUrl();
final String username = config.getUsername();
final String password = config.getPassword();
final String dsClassName = config.getDataSourceClassName();
final String driverClassName = config.getDriverClassName();
final String dataSourceJNDI = config.getDataSourceJNDI();
final Properties dataSourceProperties = config.getDataSourceProperties();
DataSource dataSource = config.getDataSource();
if (dsClassName != null && dataSource == null) {
dataSource = createInstance(dsClassName, DataSource.class);
PropertyElf.setTargetFromProperties(dataSource, dataSourceProperties);
}
else if (jdbcUrl != null && dataSource == null) {
dataSource = new DriverDataSource(jdbcUrl, driverClassName, dataSourceProperties, username, password);
}
else if (dataSourceJNDI != null && dataSource == null) {
try {
InitialContext ic = new InitialContext();
dataSource = (DataSource) ic.lookup(dataSourceJNDI);
} catch (NamingException e) {
throw new PoolInitializationException(e);
}
}
if (dataSource != null) {
setLoginTimeout(dataSource);
createNetworkTimeoutExecutor(dataSource, dsClassName, jdbcUrl);
}
this.dataSource = dataSource;
}
/**
* Obtain connection from data source.
*
* @return a Connection connection
*/
private Connection newConnection() throws Exception
{
final long start = currentTime();
Connection connection = null;
try {
String username = config.getUsername();
String password = config.getPassword();
connection = (username == null) ? dataSource.getConnection() : dataSource.getConnection(username, password);
if (connection == null) {
throw new SQLTransientConnectionException("DataSource returned null unexpectedly");
}
setupConnection(connection);
lastConnectionFailure.set(null);
return connection;
}
catch (Exception e) {
if (connection != null) {
quietlyCloseConnection(connection, "(Failed to create/setup connection)");
}
else if (getLastConnectionFailure() == null) {
LOGGER.debug("{} - Failed to create/setup connection: {}", poolName, e.getMessage());
}
lastConnectionFailure.set(e);
throw e;
}
finally {
// tracker will be null during failFast check
if (metricsTracker != null) {
metricsTracker.recordConnectionCreated(elapsedMillis(start));
}
}
}
/**
* Setup a connection initial state.
*
* @param connection a Connection
* @throws ConnectionSetupException thrown if any exception is encountered
*/
private void setupConnection(final Connection connection) throws ConnectionSetupException
{
try {
if (networkTimeout == UNINITIALIZED) {
networkTimeout = getAndSetNetworkTimeout(connection, validationTimeout);
}
else {
setNetworkTimeout(connection, validationTimeout);
}
connection.setReadOnly(isReadOnly);
connection.setAutoCommit(isAutoCommit);
checkDriverSupport(connection);
if (transactionIsolation != defaultTransactionIsolation) {
connection.setTransactionIsolation(transactionIsolation);
}
if (catalog != null) {
connection.setCatalog(catalog);
}
if (schema != null) {
connection.setSchema(schema);
}
executeSql(connection, config.getConnectionInitSql(), true);
setNetworkTimeout(connection, networkTimeout);
}
catch (SQLException e) {
throw new ConnectionSetupException(e);
}
}
/**
* Execute isValid() or connection test query.
*
* @param connection a Connection to check
*/
private void checkDriverSupport(final Connection connection) throws SQLException
{
if (!isValidChecked) {
try {
if (isUseJdbc4Validation) {
connection.isValid(1);
}
else {
executeSql(connection, config.getConnectionTestQuery(), false);
}
}
catch (Throwable e) {
LOGGER.error("{} - Failed to execute" + (isUseJdbc4Validation ? " isValid() for connection, configure" : "") + " connection test query ({}).", poolName, e.getMessage());
throw e;
}
try {
defaultTransactionIsolation = connection.getTransactionIsolation();
if (transactionIsolation == -1) {
transactionIsolation = defaultTransactionIsolation;
}
}
catch (SQLException e) {
LOGGER.warn("{} - Default transaction isolation level detection failed ({}).", poolName, e.getMessage());
if (e.getSQLState() != null && !e.getSQLState().startsWith("08")) {
throw e;
}
}
isValidChecked = true;
}
}
/**
* Set the query timeout, if it is supported by the driver.
*
* @param statement a statement to set the query timeout on
* @param timeoutSec the number of seconds before timeout
*/
private void setQueryTimeout(final Statement statement, final int timeoutSec)
{
if (isQueryTimeoutSupported != FALSE) {
try {
statement.setQueryTimeout(timeoutSec);
isQueryTimeoutSupported = TRUE;
}
catch (Throwable e) {
if (isQueryTimeoutSupported == UNINITIALIZED) {
isQueryTimeoutSupported = FALSE;
LOGGER.info("{} - Failed to set query timeout for statement. ({})", poolName, e.getMessage());
}
}
}
}
/**
* Set the network timeout, if isUseNetworkTimeout is true and the
* driver supports it. Return the pre-existing value of the network timeout.
*
* @param connection the connection to set the network timeout on
* @param timeoutMs the number of milliseconds before timeout
* @return the pre-existing network timeout value
*/
private int getAndSetNetworkTimeout(final Connection connection, final long timeoutMs)
{
if (isNetworkTimeoutSupported != FALSE) {
try {
final int originalTimeout = connection.getNetworkTimeout();
connection.setNetworkTimeout(netTimeoutExecutor, (int) timeoutMs);
isNetworkTimeoutSupported = TRUE;
return originalTimeout;
}
catch (Throwable e) {
if (isNetworkTimeoutSupported == UNINITIALIZED) {
isNetworkTimeoutSupported = FALSE;
LOGGER.info("{} - Driver does not support get/set network timeout for connections. ({})", poolName, e.getMessage());
if (validationTimeout < SECONDS.toMillis(1)) {
LOGGER.warn("{} - A validationTimeout of less than 1 second cannot be honored on drivers without setNetworkTimeout() support.", poolName);
}
else if (validationTimeout % SECONDS.toMillis(1) != 0) {
LOGGER.warn("{} - A validationTimeout with fractional second granularity cannot be honored on drivers without setNetworkTimeout() support.", poolName);
}
}
}
}
return 0;
}
/**
* Set the network timeout, if isUseNetworkTimeout is true and the
* driver supports it.
*
* @param connection the connection to set the network timeout on
* @param timeoutMs the number of milliseconds before timeout
* @throws SQLException throw if the connection.setNetworkTimeout() call throws
*/
private void setNetworkTimeout(final Connection connection, final long timeoutMs) throws SQLException
{
if (isNetworkTimeoutSupported == TRUE) {
connection.setNetworkTimeout(netTimeoutExecutor, (int) timeoutMs);
}
}
/**
* Execute the user-specified init SQL.
*
* @param connection the connection to initialize
* @param sql the SQL to execute
* @param isCommit whether to commit the SQL after execution or not
* @throws SQLException throws if the init SQL execution fails
*/
private void executeSql(final Connection connection, final String sql, final boolean isCommit) throws SQLException
{
if (sql != null) {
try (Statement statement = connection.createStatement()) {
// connection was created a few milliseconds before, so set query timeout is omitted (we assume it will succeed)
statement.execute(sql);
}
if (isIsolateInternalQueries && !isAutoCommit) {
if (isCommit) {
connection.commit();
}
else {
connection.rollback();
}
}
}
}
private void createNetworkTimeoutExecutor(final DataSource dataSource, final String dsClassName, final String jdbcUrl)
{
// Temporary hack for MySQL issue: http://bugs.mysql.com/bug.php?id=75615
if ((dsClassName != null && dsClassName.contains("Mysql")) ||
(jdbcUrl != null && jdbcUrl.contains("mysql")) ||
(dataSource != null && dataSource.getClass().getName().contains("Mysql"))) {
netTimeoutExecutor = new SynchronousExecutor();
}
else {
ThreadFactory threadFactory = config.getThreadFactory();
threadFactory = threadFactory != null ? threadFactory : new DefaultThreadFactory(poolName + " network timeout executor", true);
ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool(threadFactory);
executor.setKeepAliveTime(15, SECONDS);
executor.allowCoreThreadTimeOut(true);
netTimeoutExecutor = executor;
}
}
/**
* Set the loginTimeout on the specified DataSource.
*
* @param dataSource the DataSource
*/
private void setLoginTimeout(final DataSource dataSource)
{
if (connectionTimeout != Integer.MAX_VALUE) {
try {
dataSource.setLoginTimeout(Math.max(1, (int) MILLISECONDS.toSeconds(500L + connectionTimeout)));
}
catch (Throwable e) {
LOGGER.info("{} - Failed to set login timeout for data source. ({})", poolName, e.getMessage());
}
}
}
/**
* This will create a string for debug logging. Given a set of "reset bits", this
* method will return a concatenated string, for example:
*
* Input : 0b00110
* Output: "autoCommit, isolation"
*
* @param bits a set of "reset bits"
* @return a string of which states were reset
*/
private String stringFromResetBits(final int bits)
{
final StringBuilder sb = new StringBuilder();
for (int ndx = 0; ndx < RESET_STATES.length; ndx++) {
if ( (bits & (0b1 << ndx)) != 0) {
sb.append(RESET_STATES[ndx]).append(", ");
}
}
sb.setLength(sb.length() - 2); // trim trailing comma
return sb.toString();
}
// ***********************************************************************
// Private Static Classes
// ***********************************************************************
static class ConnectionSetupException extends Exception
{
private static final long serialVersionUID = 929872118275916521L;
ConnectionSetupException(Throwable t)
{
super(t);
}
}
/**
* Special executor used only to work around a MySQL issue that has not been addressed.
* MySQL issue: http://bugs.mysql.com/bug.php?id=75615
*/
private static class SynchronousExecutor implements Executor
{
/** {@inheritDoc} */
@Override
public void execute(Runnable command)
{
try {
command.run();
}
catch (Throwable t) {
LoggerFactory.getLogger(PoolBase.class).debug("Failed to execute: {}", command, t);
}
}
}
interface IMetricsTrackerDelegate extends AutoCloseable
{
default void recordConnectionUsage(PoolEntry poolEntry) {}
default void recordConnectionCreated(long connectionCreatedMillis) {}
default void recordBorrowTimeoutStats(long startTime) {}
default void recordBorrowStats(final PoolEntry poolEntry, final long startTime) {}
default void recordConnectionTimeout() {}
@Override
default void close() {}
}
/**
* A class that delegates to a MetricsTracker implementation. The use of a delegate
* allows us to use the NopMetricsTrackerDelegate when metrics are disabled, which in
* turn allows the JIT to completely optimize away to callsites to record metrics.
*/
static class MetricsTrackerDelegate implements IMetricsTrackerDelegate
{
final IMetricsTracker tracker;
MetricsTrackerDelegate(IMetricsTracker tracker)
{
this.tracker = tracker;
}
@Override
public void recordConnectionUsage(final PoolEntry poolEntry)
{
tracker.recordConnectionUsageMillis(poolEntry.getMillisSinceBorrowed());
}
@Override
public void recordConnectionCreated(long connectionCreatedMillis)
{
tracker.recordConnectionCreatedMillis(connectionCreatedMillis);
}
@Override
public void recordBorrowTimeoutStats(long startTime)
{
tracker.recordConnectionAcquiredNanos(elapsedNanos(startTime));
}
@Override
public void recordBorrowStats(final PoolEntry poolEntry, final long startTime)
{
final long now = currentTime();
poolEntry.lastBorrowed = now;
tracker.recordConnectionAcquiredNanos(elapsedNanos(startTime, now));
}
@Override
public void recordConnectionTimeout() {
tracker.recordConnectionTimeout();
}
@Override
public void close()
{
tracker.close();
}
}
/**
* A no-op implementation of the IMetricsTrackerDelegate that is used when metrics capture is
* disabled.
*/
static final class NopMetricsTrackerDelegate implements IMetricsTrackerDelegate {}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/PoolEntry.java 0000664 0000000 0000000 00000012153 13154316420 0026355 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import com.zaxxer.hikari.util.ConcurrentBag.IConcurrentBagEntry;
import com.zaxxer.hikari.util.FastList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import static com.zaxxer.hikari.util.ClockSource.*;
/**
* Entry used in the ConcurrentBag to track Connection instances.
*
* @author Brett Wooldridge
*/
final class PoolEntry implements IConcurrentBagEntry
{
private static final Logger LOGGER = LoggerFactory.getLogger(PoolEntry.class);
private static final AtomicIntegerFieldUpdater stateUpdater;
Connection connection;
long lastAccessed;
long lastBorrowed;
@SuppressWarnings("FieldCanBeLocal")
private volatile int state = 0;
private volatile boolean evict;
private volatile ScheduledFuture endOfLife;
private final FastList openStatements;
private final HikariPool hikariPool;
private final boolean isReadOnly;
private final boolean isAutoCommit;
static
{
stateUpdater = AtomicIntegerFieldUpdater.newUpdater(PoolEntry.class, "state");
}
PoolEntry(final Connection connection, final PoolBase pool, final boolean isReadOnly, final boolean isAutoCommit)
{
this.connection = connection;
this.hikariPool = (HikariPool) pool;
this.isReadOnly = isReadOnly;
this.isAutoCommit = isAutoCommit;
this.lastAccessed = currentTime();
this.openStatements = new FastList<>(Statement.class, 16);
}
/**
* Release this entry back to the pool.
*
* @param lastAccessed last access time-stamp
*/
void recycle(final long lastAccessed)
{
if (connection != null) {
this.lastAccessed = lastAccessed;
hikariPool.recycle(this);
}
}
/**
* Set the end of life {@link ScheduledFuture}.
*
* @param endOfLife this PoolEntry/Connection's end of life {@link ScheduledFuture}
*/
void setFutureEol(final ScheduledFuture endOfLife)
{
this.endOfLife = endOfLife;
}
Connection createProxyConnection(final ProxyLeakTask leakTask, final long now)
{
return ProxyFactory.getProxyConnection(this, connection, openStatements, leakTask, now, isReadOnly, isAutoCommit);
}
void resetConnectionState(final ProxyConnection proxyConnection, final int dirtyBits) throws SQLException
{
hikariPool.resetConnectionState(connection, proxyConnection, dirtyBits);
}
String getPoolName()
{
return hikariPool.toString();
}
boolean isMarkedEvicted()
{
return evict;
}
void markEvicted()
{
this.evict = true;
}
void evict(final String closureReason)
{
hikariPool.closeConnection(this, closureReason);
}
/** Returns millis since lastBorrowed */
long getMillisSinceBorrowed()
{
return elapsedMillis(lastBorrowed);
}
/** {@inheritDoc} */
@Override
public String toString()
{
final long now = currentTime();
return connection
+ ", accessed " + elapsedDisplayString(lastAccessed, now) + " ago, "
+ stateToString();
}
// ***********************************************************************
// IConcurrentBagEntry methods
// ***********************************************************************
/** {@inheritDoc} */
@Override
public int getState()
{
return stateUpdater.get(this);
}
/** {@inheritDoc} */
@Override
public boolean compareAndSet(int expect, int update)
{
return stateUpdater.compareAndSet(this, expect, update);
}
/** {@inheritDoc} */
@Override
public void setState(int update)
{
stateUpdater.set(this, update);
}
Connection close()
{
ScheduledFuture eol = endOfLife;
if (eol != null && !eol.isDone() && !eol.cancel(false)) {
LOGGER.warn("{} - maxLifeTime expiration task cancellation unexpectedly returned false for connection {}", getPoolName(), connection);
}
Connection con = connection;
connection = null;
endOfLife = null;
return con;
}
private String stateToString()
{
switch (state) {
case STATE_IN_USE:
return "IN_USE";
case STATE_NOT_IN_USE:
return "NOT_IN_USE";
case STATE_REMOVED:
return "REMOVED";
case STATE_RESERVED:
return "RESERVED";
default:
return "Invalid";
}
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/ProxyCallableStatement.java 0000664 0000000 0000000 00000002325 13154316420 0031050 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import java.sql.CallableStatement;
/**
* This is the proxy class for java.sql.CallableStatement.
*
* @author Brett Wooldridge
*/
public abstract class ProxyCallableStatement extends ProxyPreparedStatement implements CallableStatement
{
protected ProxyCallableStatement(ProxyConnection connection, CallableStatement statement)
{
super(connection, statement);
}
// **********************************************************************
// Overridden java.sql.CallableStatement Methods
// **********************************************************************
} HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/ProxyConnection.java 0000664 0000000 0000000 00000036201 13154316420 0027563 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013, 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import static com.zaxxer.hikari.util.ClockSource.currentTime;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Wrapper;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Executor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.zaxxer.hikari.util.FastList;
/**
* This is the proxy class for java.sql.Connection.
*
* @author Brett Wooldridge
*/
public abstract class ProxyConnection implements Connection
{
static final int DIRTY_BIT_READONLY = 0b000001;
static final int DIRTY_BIT_AUTOCOMMIT = 0b000010;
static final int DIRTY_BIT_ISOLATION = 0b000100;
static final int DIRTY_BIT_CATALOG = 0b001000;
static final int DIRTY_BIT_NETTIMEOUT = 0b010000;
static final int DIRTY_BIT_SCHEMA = 0b100000;
private static final Logger LOGGER;
private static final Set ERROR_STATES;
private static final Set ERROR_CODES;
@SuppressWarnings("WeakerAccess")
protected Connection delegate;
private final PoolEntry poolEntry;
private final ProxyLeakTask leakTask;
private final FastList openStatements;
private int dirtyBits;
private long lastAccess;
private boolean isCommitStateDirty;
private boolean isReadOnly;
private boolean isAutoCommit;
private int networkTimeout;
private int transactionIsolation;
private String dbcatalog;
private String dbschema;
// static initializer
static {
LOGGER = LoggerFactory.getLogger(ProxyConnection.class);
ERROR_STATES = new HashSet<>();
ERROR_STATES.add("57P01"); // ADMIN SHUTDOWN
ERROR_STATES.add("57P02"); // CRASH SHUTDOWN
ERROR_STATES.add("57P03"); // CANNOT CONNECT NOW
ERROR_STATES.add("01002"); // SQL92 disconnect error
ERROR_STATES.add("JZ0C0"); // Sybase disconnect error
ERROR_STATES.add("JZ0C1"); // Sybase disconnect error
ERROR_CODES = new HashSet<>();
ERROR_CODES.add(500150);
ERROR_CODES.add(2399);
}
protected ProxyConnection(final PoolEntry poolEntry, final Connection connection, final FastList openStatements, final ProxyLeakTask leakTask, final long now, final boolean isReadOnly, final boolean isAutoCommit) {
this.poolEntry = poolEntry;
this.delegate = connection;
this.openStatements = openStatements;
this.leakTask = leakTask;
this.lastAccess = now;
this.isReadOnly = isReadOnly;
this.isAutoCommit = isAutoCommit;
}
/** {@inheritDoc} */
@Override
public final String toString()
{
return this.getClass().getSimpleName() + '@' + System.identityHashCode(this) + " wrapping " + delegate;
}
// ***********************************************************************
// Connection State Accessors
// ***********************************************************************
final boolean getAutoCommitState()
{
return isAutoCommit;
}
final String getCatalogState()
{
return dbcatalog;
}
final String getSchemaState()
{
return dbschema;
}
final int getTransactionIsolationState()
{
return transactionIsolation;
}
final boolean getReadOnlyState()
{
return isReadOnly;
}
final int getNetworkTimeoutState()
{
return networkTimeout;
}
// ***********************************************************************
// Internal methods
// ***********************************************************************
final PoolEntry getPoolEntry()
{
return poolEntry;
}
final SQLException checkException(SQLException sqle)
{
SQLException nse = sqle;
for (int depth = 0; delegate != ClosedConnection.CLOSED_CONNECTION && nse != null && depth < 10; depth++) {
final String sqlState = nse.getSQLState();
if (sqlState != null && sqlState.startsWith("08") || ERROR_STATES.contains(sqlState) || ERROR_CODES.contains(nse.getErrorCode())) {
// broken connection
LOGGER.warn("{} - Connection {} marked as broken because of SQLSTATE({}), ErrorCode({})",
poolEntry.getPoolName(), delegate, sqlState, nse.getErrorCode(), nse);
leakTask.cancel();
poolEntry.evict("(connection is broken)");
delegate = ClosedConnection.CLOSED_CONNECTION;
}
else {
nse = nse.getNextException();
}
}
return sqle;
}
final synchronized void untrackStatement(final Statement statement)
{
openStatements.remove(statement);
}
final void markCommitStateDirty()
{
if (isAutoCommit) {
lastAccess = currentTime();
}
else {
isCommitStateDirty = true;
}
}
void cancelLeakTask()
{
leakTask.cancel();
}
private synchronized T trackStatement(final T statement)
{
openStatements.add(statement);
return statement;
}
@SuppressWarnings("EmptyTryBlock")
private synchronized void closeStatements()
{
final int size = openStatements.size();
if (size > 0) {
for (int i = 0; i < size && delegate != ClosedConnection.CLOSED_CONNECTION; i++) {
try (Statement ignored = openStatements.get(i)) {
// automatic resource cleanup
}
catch (SQLException e) {
LOGGER.warn("{} - Connection {} marked as broken because of an exception closing open statements during Connection.close()",
poolEntry.getPoolName(), delegate);
leakTask.cancel();
poolEntry.evict("(exception closing Statements during Connection.close())");
delegate = ClosedConnection.CLOSED_CONNECTION;
}
}
openStatements.clear();
}
}
// **********************************************************************
// "Overridden" java.sql.Connection Methods
// **********************************************************************
/** {@inheritDoc} */
@Override
public final void close() throws SQLException
{
// Closing statements can cause connection eviction, so this must run before the conditional below
closeStatements();
if (delegate != ClosedConnection.CLOSED_CONNECTION) {
leakTask.cancel();
try {
if (isCommitStateDirty && !isAutoCommit) {
delegate.rollback();
lastAccess = currentTime();
LOGGER.debug("{} - Executed rollback on connection {} due to dirty commit state on close().", poolEntry.getPoolName(), delegate);
}
if (dirtyBits != 0) {
poolEntry.resetConnectionState(this, dirtyBits);
lastAccess = currentTime();
}
delegate.clearWarnings();
}
catch (SQLException e) {
// when connections are aborted, exceptions are often thrown that should not reach the application
if (!poolEntry.isMarkedEvicted()) {
throw checkException(e);
}
}
finally {
delegate = ClosedConnection.CLOSED_CONNECTION;
poolEntry.recycle(lastAccess);
}
}
}
/** {@inheritDoc} */
@Override
public boolean isClosed() throws SQLException
{
return (delegate == ClosedConnection.CLOSED_CONNECTION);
}
/** {@inheritDoc} */
@Override
public Statement createStatement() throws SQLException
{
return ProxyFactory.getProxyStatement(this, trackStatement(delegate.createStatement()));
}
/** {@inheritDoc} */
@Override
public Statement createStatement(int resultSetType, int concurrency) throws SQLException
{
return ProxyFactory.getProxyStatement(this, trackStatement(delegate.createStatement(resultSetType, concurrency)));
}
/** {@inheritDoc} */
@Override
public Statement createStatement(int resultSetType, int concurrency, int holdability) throws SQLException
{
return ProxyFactory.getProxyStatement(this, trackStatement(delegate.createStatement(resultSetType, concurrency, holdability)));
}
/** {@inheritDoc} */
@Override
public CallableStatement prepareCall(String sql) throws SQLException
{
return ProxyFactory.getProxyCallableStatement(this, trackStatement(delegate.prepareCall(sql)));
}
/** {@inheritDoc} */
@Override
public CallableStatement prepareCall(String sql, int resultSetType, int concurrency) throws SQLException
{
return ProxyFactory.getProxyCallableStatement(this, trackStatement(delegate.prepareCall(sql, resultSetType, concurrency)));
}
/** {@inheritDoc} */
@Override
public CallableStatement prepareCall(String sql, int resultSetType, int concurrency, int holdability) throws SQLException
{
return ProxyFactory.getProxyCallableStatement(this, trackStatement(delegate.prepareCall(sql, resultSetType, concurrency, holdability)));
}
/** {@inheritDoc} */
@Override
public PreparedStatement prepareStatement(String sql) throws SQLException
{
return ProxyFactory.getProxyPreparedStatement(this, trackStatement(delegate.prepareStatement(sql)));
}
/** {@inheritDoc} */
@Override
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException
{
return ProxyFactory.getProxyPreparedStatement(this, trackStatement(delegate.prepareStatement(sql, autoGeneratedKeys)));
}
/** {@inheritDoc} */
@Override
public PreparedStatement prepareStatement(String sql, int resultSetType, int concurrency) throws SQLException
{
return ProxyFactory.getProxyPreparedStatement(this, trackStatement(delegate.prepareStatement(sql, resultSetType, concurrency)));
}
/** {@inheritDoc} */
@Override
public PreparedStatement prepareStatement(String sql, int resultSetType, int concurrency, int holdability) throws SQLException
{
return ProxyFactory.getProxyPreparedStatement(this, trackStatement(delegate.prepareStatement(sql, resultSetType, concurrency, holdability)));
}
/** {@inheritDoc} */
@Override
public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException
{
return ProxyFactory.getProxyPreparedStatement(this, trackStatement(delegate.prepareStatement(sql, columnIndexes)));
}
/** {@inheritDoc} */
@Override
public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException
{
return ProxyFactory.getProxyPreparedStatement(this, trackStatement(delegate.prepareStatement(sql, columnNames)));
}
/** {@inheritDoc} */
@Override
public DatabaseMetaData getMetaData() throws SQLException
{
markCommitStateDirty();
return delegate.getMetaData();
}
/** {@inheritDoc} */
@Override
public void commit() throws SQLException
{
delegate.commit();
isCommitStateDirty = false;
lastAccess = currentTime();
}
/** {@inheritDoc} */
@Override
public void rollback() throws SQLException
{
delegate.rollback();
isCommitStateDirty = false;
lastAccess = currentTime();
}
/** {@inheritDoc} */
@Override
public void rollback(Savepoint savepoint) throws SQLException
{
delegate.rollback(savepoint);
isCommitStateDirty = false;
lastAccess = currentTime();
}
/** {@inheritDoc} */
@Override
public void setAutoCommit(boolean autoCommit) throws SQLException
{
delegate.setAutoCommit(autoCommit);
isAutoCommit = autoCommit;
dirtyBits |= DIRTY_BIT_AUTOCOMMIT;
}
/** {@inheritDoc} */
@Override
public void setReadOnly(boolean readOnly) throws SQLException
{
delegate.setReadOnly(readOnly);
isReadOnly = readOnly;
isCommitStateDirty = false;
dirtyBits |= DIRTY_BIT_READONLY;
}
/** {@inheritDoc} */
@Override
public void setTransactionIsolation(int level) throws SQLException
{
delegate.setTransactionIsolation(level);
transactionIsolation = level;
dirtyBits |= DIRTY_BIT_ISOLATION;
}
/** {@inheritDoc} */
@Override
public void setCatalog(String catalog) throws SQLException
{
delegate.setCatalog(catalog);
dbcatalog = catalog;
dirtyBits |= DIRTY_BIT_CATALOG;
}
/** {@inheritDoc} */
@Override
public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException
{
delegate.setNetworkTimeout(executor, milliseconds);
networkTimeout = milliseconds;
dirtyBits |= DIRTY_BIT_NETTIMEOUT;
}
/** {@inheritDoc} */
@Override
public void setSchema(String schema) throws SQLException
{
delegate.setSchema(schema);
dbschema = schema;
dirtyBits |= DIRTY_BIT_SCHEMA;
}
/** {@inheritDoc} */
@Override
public final boolean isWrapperFor(Class iface) throws SQLException
{
return iface.isInstance(delegate) || (delegate instanceof Wrapper && delegate.isWrapperFor(iface));
}
/** {@inheritDoc} */
@Override
@SuppressWarnings("unchecked")
public final T unwrap(Class iface) throws SQLException
{
if (iface.isInstance(delegate)) {
return (T) delegate;
}
else if (delegate instanceof Wrapper) {
return delegate.unwrap(iface);
}
throw new SQLException("Wrapped connection is not an instance of " + iface);
}
// **********************************************************************
// Private classes
// **********************************************************************
private static final class ClosedConnection
{
static final Connection CLOSED_CONNECTION = getClosedConnection();
private static Connection getClosedConnection()
{
InvocationHandler handler = (proxy, method, args) -> {
final String methodName = method.getName();
if ("abort".equals(methodName)) {
return Void.TYPE;
}
else if ("isValid".equals(methodName)) {
return Boolean.FALSE;
}
else if ("toString".equals(methodName)) {
return ClosedConnection.class.getCanonicalName();
}
throw new SQLException("Connection is closed");
};
return (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), new Class[] { Connection.class }, handler);
}
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/ProxyFactory.java 0000664 0000000 0000000 00000006465 13154316420 0027104 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013, 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import com.zaxxer.hikari.util.FastList;
/**
* A factory class that produces proxies around instances of the standard
* JDBC interfaces.
*
* @author Brett Wooldridge
*/
@SuppressWarnings("unused")
public final class ProxyFactory
{
private ProxyFactory()
{
// unconstructable
}
/**
* Create a proxy for the specified {@link Connection} instance.
* @param poolEntry the PoolEntry holding pool state
* @param connection the raw database Connection
* @param openStatements a reusable list to track open Statement instances
* @param leakTask the ProxyLeakTask for this connection
* @param now the current timestamp
* @param isReadOnly the default readOnly state of the connection
* @param isAutoCommit the default autoCommit state of the connection
* @return a proxy that wraps the specified {@link Connection}
*/
static ProxyConnection getProxyConnection(final PoolEntry poolEntry, final Connection connection, final FastList openStatements, final ProxyLeakTask leakTask, final long now, final boolean isReadOnly, final boolean isAutoCommit)
{
// Body is replaced (injected) by JavassistProxyFactory
throw new IllegalStateException("You need to run the CLI build and you need target/classes in your classpath to run.");
}
static Statement getProxyStatement(final ProxyConnection connection, final Statement statement)
{
// Body is replaced (injected) by JavassistProxyFactory
throw new IllegalStateException("You need to run the CLI build and you need target/classes in your classpath to run.");
}
static CallableStatement getProxyCallableStatement(final ProxyConnection connection, final CallableStatement statement)
{
// Body is replaced (injected) by JavassistProxyFactory
throw new IllegalStateException("You need to run the CLI build and you need target/classes in your classpath to run.");
}
static PreparedStatement getProxyPreparedStatement(final ProxyConnection connection, final PreparedStatement statement)
{
// Body is replaced (injected) by JavassistProxyFactory
throw new IllegalStateException("You need to run the CLI build and you need target/classes in your classpath to run.");
}
static ResultSet getProxyResultSet(final ProxyConnection connection, final ProxyStatement statement, final ResultSet resultSet)
{
// Body is replaced (injected) by JavassistProxyFactory
throw new IllegalStateException("You need to run the CLI build and you need target/classes in your classpath to run.");
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/ProxyLeakTask.java 0000664 0000000 0000000 00000005267 13154316420 0027173 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013, 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A Runnable that is scheduled in the future to report leaks. The ScheduledFuture is
* cancelled if the connection is closed before the leak time expires.
*
* @author Brett Wooldridge
*/
class ProxyLeakTask implements Runnable
{
private static final Logger LOGGER = LoggerFactory.getLogger(ProxyLeakTask.class);
static final ProxyLeakTask NO_LEAK;
private ScheduledFuture scheduledFuture;
private String connectionName;
private Exception exception;
private boolean isLeaked;
static
{
NO_LEAK = new ProxyLeakTask() {
@Override
void schedule(ScheduledExecutorService executorService, long leakDetectionThreshold) {}
@Override
public void run() {}
@Override
public void cancel() {}
};
}
ProxyLeakTask(final PoolEntry poolEntry)
{
this.exception = new Exception("Apparent connection leak detected");
this.connectionName = poolEntry.connection.toString();
}
private ProxyLeakTask()
{
}
void schedule(ScheduledExecutorService executorService, long leakDetectionThreshold)
{
scheduledFuture = executorService.schedule(this, leakDetectionThreshold, TimeUnit.MILLISECONDS);
}
/** {@inheritDoc} */
@Override
public void run()
{
isLeaked = true;
final StackTraceElement[] stackTrace = exception.getStackTrace();
final StackTraceElement[] trace = new StackTraceElement[stackTrace.length - 5];
System.arraycopy(stackTrace, 5, trace, 0, trace.length);
exception.setStackTrace(trace);
LOGGER.warn("Connection leak detection triggered for {}, stack trace follows", connectionName, exception);
}
void cancel()
{
scheduledFuture.cancel(false);
if (isLeaked) {
LOGGER.info("Previously reported leaked connection {} was returned to the pool (unleaked)", connectionName);
}
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/ProxyLeakTaskFactory.java 0000664 0000000 0000000 00000003267 13154316420 0030521 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013, 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import java.util.concurrent.ScheduledExecutorService;
/**
* A factory for {@link ProxyLeakTask} Runnables that are scheduled in the future to report leaks.
*
* @author Brett Wooldridge
* @author Andreas Brenk
*/
class ProxyLeakTaskFactory
{
private ScheduledExecutorService executorService;
private long leakDetectionThreshold;
ProxyLeakTaskFactory(final long leakDetectionThreshold, final ScheduledExecutorService executorService)
{
this.executorService = executorService;
this.leakDetectionThreshold = leakDetectionThreshold;
}
ProxyLeakTask schedule(final PoolEntry poolEntry)
{
return (leakDetectionThreshold == 0) ? ProxyLeakTask.NO_LEAK : scheduleNewTask(poolEntry);
}
void updateLeakDetectionThreshold(final long leakDetectionThreshold)
{
this.leakDetectionThreshold = leakDetectionThreshold;
}
private ProxyLeakTask scheduleNewTask(PoolEntry poolEntry) {
ProxyLeakTask task = new ProxyLeakTask(poolEntry);
task.schedule(executorService, leakDetectionThreshold);
return task;
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/ProxyPreparedStatement.java 0000664 0000000 0000000 00000004173 13154316420 0031116 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* This is the proxy class for java.sql.PreparedStatement.
*
* @author Brett Wooldridge
*/
public abstract class ProxyPreparedStatement extends ProxyStatement implements PreparedStatement
{
ProxyPreparedStatement(ProxyConnection connection, PreparedStatement statement)
{
super(connection, statement);
}
// **********************************************************************
// Overridden java.sql.PreparedStatement Methods
// **********************************************************************
/** {@inheritDoc} */
@Override
public boolean execute() throws SQLException
{
connection.markCommitStateDirty();
return ((PreparedStatement) delegate).execute();
}
/** {@inheritDoc} */
@Override
public ResultSet executeQuery() throws SQLException
{
connection.markCommitStateDirty();
ResultSet resultSet = ((PreparedStatement) delegate).executeQuery();
return ProxyFactory.getProxyResultSet(connection, this, resultSet);
}
/** {@inheritDoc} */
@Override
public int executeUpdate() throws SQLException
{
connection.markCommitStateDirty();
return ((PreparedStatement) delegate).executeUpdate();
}
/** {@inheritDoc} */
@Override
public long executeLargeUpdate() throws SQLException
{
connection.markCommitStateDirty();
return ((PreparedStatement) delegate).executeLargeUpdate();
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/ProxyResultSet.java 0000664 0000000 0000000 00000005323 13154316420 0027417 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013, 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* This is the proxy class for java.sql.ResultSet.
*
* @author Brett Wooldridge
*/
public abstract class ProxyResultSet implements ResultSet
{
protected final ProxyConnection connection;
protected final ProxyStatement statement;
final ResultSet delegate;
protected ProxyResultSet(ProxyConnection connection, ProxyStatement statement, ResultSet resultSet)
{
this.connection = connection;
this.statement = statement;
this.delegate = resultSet;
}
@SuppressWarnings("unused")
final SQLException checkException(SQLException e)
{
return connection.checkException(e);
}
/** {@inheritDoc} */
@Override
public String toString()
{
return this.getClass().getSimpleName() + '@' + System.identityHashCode(this) + " wrapping " + delegate;
}
// **********************************************************************
// Overridden java.sql.ResultSet Methods
// **********************************************************************
/** {@inheritDoc} */
@Override
public final Statement getStatement() throws SQLException
{
return statement;
}
/** {@inheritDoc} */
@Override
public void updateRow() throws SQLException
{
connection.markCommitStateDirty();
delegate.updateRow();
}
/** {@inheritDoc} */
@Override
public void insertRow() throws SQLException
{
connection.markCommitStateDirty();
delegate.insertRow();
}
/** {@inheritDoc} */
@Override
public void deleteRow() throws SQLException
{
connection.markCommitStateDirty();
delegate.deleteRow();
}
/** {@inheritDoc} */
@Override
@SuppressWarnings("unchecked")
public final T unwrap(Class iface) throws SQLException
{
if (iface.isInstance(delegate)) {
return (T) delegate;
}
else if (delegate != null) {
return delegate.unwrap(iface);
}
throw new SQLException("Wrapped ResultSet is not an instance of " + iface);
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/pool/ProxyStatement.java 0000664 0000000 0000000 00000014532 13154316420 0027433 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.pool;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* This is the proxy class for java.sql.Statement.
*
* @author Brett Wooldridge
*/
public abstract class ProxyStatement implements Statement
{
protected final ProxyConnection connection;
final Statement delegate;
private boolean isClosed;
private ResultSet proxyResultSet;
ProxyStatement(ProxyConnection connection, Statement statement)
{
this.connection = connection;
this.delegate = statement;
}
@SuppressWarnings("unused")
final SQLException checkException(SQLException e)
{
return connection.checkException(e);
}
/** {@inheritDoc} */
@Override
public final String toString()
{
final String delegateToString = delegate.toString();
return this.getClass().getSimpleName() + '@' + System.identityHashCode(this) + " wrapping " + delegateToString;
}
// **********************************************************************
// Overridden java.sql.Statement Methods
// **********************************************************************
/** {@inheritDoc} */
@Override
public final void close() throws SQLException
{
synchronized (this) {
if (isClosed) {
return;
}
isClosed = true;
}
connection.untrackStatement(delegate);
try {
delegate.close();
}
catch (SQLException e) {
throw connection.checkException(e);
}
}
/** {@inheritDoc} */
@Override
public Connection getConnection() throws SQLException
{
return connection;
}
/** {@inheritDoc} */
@Override
public boolean execute(String sql) throws SQLException
{
connection.markCommitStateDirty();
return delegate.execute(sql);
}
/** {@inheritDoc} */
@Override
public boolean execute(String sql, int autoGeneratedKeys) throws SQLException
{
connection.markCommitStateDirty();
return delegate.execute(sql, autoGeneratedKeys);
}
/** {@inheritDoc} */
@Override
public ResultSet executeQuery(String sql) throws SQLException
{
connection.markCommitStateDirty();
ResultSet resultSet = delegate.executeQuery(sql);
return ProxyFactory.getProxyResultSet(connection, this, resultSet);
}
/** {@inheritDoc} */
@Override
public int executeUpdate(String sql) throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeUpdate(sql);
}
/** {@inheritDoc} */
@Override
public int[] executeBatch() throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeBatch();
}
/** {@inheritDoc} */
@Override
public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeUpdate(sql, autoGeneratedKeys);
}
/** {@inheritDoc} */
@Override
public int executeUpdate(String sql, int[] columnIndexes) throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeUpdate(sql, columnIndexes);
}
/** {@inheritDoc} */
@Override
public int executeUpdate(String sql, String[] columnNames) throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeUpdate(sql, columnNames);
}
/** {@inheritDoc} */
@Override
public boolean execute(String sql, int[] columnIndexes) throws SQLException
{
connection.markCommitStateDirty();
return delegate.execute(sql, columnIndexes);
}
/** {@inheritDoc} */
@Override
public boolean execute(String sql, String[] columnNames) throws SQLException
{
connection.markCommitStateDirty();
return delegate.execute(sql, columnNames);
}
/** {@inheritDoc} */
@Override
public long[] executeLargeBatch() throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeLargeBatch();
}
/** {@inheritDoc} */
@Override
public long executeLargeUpdate(String sql) throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeLargeUpdate(sql);
}
/** {@inheritDoc} */
@Override
public long executeLargeUpdate(String sql, int autoGeneratedKeys) throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeLargeUpdate(sql, autoGeneratedKeys);
}
/** {@inheritDoc} */
@Override
public long executeLargeUpdate(String sql, int[] columnIndexes) throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeLargeUpdate(sql, columnIndexes);
}
/** {@inheritDoc} */
@Override
public long executeLargeUpdate(String sql, String[] columnNames) throws SQLException
{
connection.markCommitStateDirty();
return delegate.executeLargeUpdate(sql, columnNames);
}
/** {@inheritDoc} */
@Override
public ResultSet getResultSet() throws SQLException {
final ResultSet resultSet = delegate.getResultSet();
if (resultSet != null) {
if (proxyResultSet == null || ((ProxyResultSet) proxyResultSet).delegate != resultSet) {
proxyResultSet = ProxyFactory.getProxyResultSet(connection, this, resultSet);
}
}
else {
proxyResultSet = null;
}
return proxyResultSet;
}
/** {@inheritDoc} */
@Override
@SuppressWarnings("unchecked")
public final T unwrap(Class iface) throws SQLException
{
if (iface.isInstance(delegate)) {
return (T) delegate;
}
else if (delegate != null) {
return delegate.unwrap(iface);
}
throw new SQLException("Wrapped statement is not an instance of " + iface);
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/util/ 0000775 0000000 0000000 00000000000 13154316420 0023561 5 ustar 00root root 0000000 0000000 HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/util/ClockSource.java 0000664 0000000 0000000 00000021711 13154316420 0026642 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2015 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.util;
import static java.util.concurrent.TimeUnit.DAYS;
import static java.util.concurrent.TimeUnit.HOURS;
import static java.util.concurrent.TimeUnit.MICROSECONDS;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.MINUTES;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
import java.util.concurrent.TimeUnit;
/**
* A resolution-independent provider of current time-stamps and elapsed time
* calculations.
*
* @author Brett Wooldridge
*/
public interface ClockSource
{
static ClockSource CLOCK = Factory.create();
/**
* Get the current time-stamp (resolution is opaque).
*
* @return the current time-stamp
*/
static long currentTime() {
return CLOCK.currentTime0();
}
long currentTime0();
/**
* Convert an opaque time-stamp returned by currentTime() into
* milliseconds.
*
* @param time an opaque time-stamp returned by an instance of this class
* @return the time-stamp in milliseconds
*/
static long toMillis(long time) {
return CLOCK.toMillis0(time);
}
long toMillis0(long time);
/**
* Convert an opaque time-stamp returned by currentTime() into
* nanoseconds.
*
* @param time an opaque time-stamp returned by an instance of this class
* @return the time-stamp in nanoseconds
*/
static long toNanos(long time) {
return CLOCK.toNanos0(time);
}
long toNanos0(long time);
/**
* Convert an opaque time-stamp returned by currentTime() into an
* elapsed time in milliseconds, based on the current instant in time.
*
* @param startTime an opaque time-stamp returned by an instance of this class
* @return the elapsed time between startTime and now in milliseconds
*/
static long elapsedMillis(long startTime) {
return CLOCK.elapsedMillis0(startTime);
}
long elapsedMillis0(long startTime);
/**
* Get the difference in milliseconds between two opaque time-stamps returned
* by currentTime().
*
* @param startTime an opaque time-stamp returned by an instance of this class
* @param endTime an opaque time-stamp returned by an instance of this class
* @return the elapsed time between startTime and endTime in milliseconds
*/
static long elapsedMillis(long startTime, long endTime) {
return CLOCK.elapsedMillis0(startTime, endTime);
}
long elapsedMillis0(long startTime, long endTime);
/**
* Convert an opaque time-stamp returned by currentTime() into an
* elapsed time in milliseconds, based on the current instant in time.
*
* @param startTime an opaque time-stamp returned by an instance of this class
* @return the elapsed time between startTime and now in milliseconds
*/
static long elapsedNanos(long startTime) {
return CLOCK.elapsedNanos0(startTime);
}
long elapsedNanos0(long startTime);
/**
* Get the difference in nanoseconds between two opaque time-stamps returned
* by currentTime().
*
* @param startTime an opaque time-stamp returned by an instance of this class
* @param endTime an opaque time-stamp returned by an instance of this class
* @return the elapsed time between startTime and endTime in nanoseconds
*/
static long elapsedNanos(long startTime, long endTime) {
return CLOCK.elapsedNanos0(startTime, endTime);
}
long elapsedNanos0(long startTime, long endTime);
/**
* Return the specified opaque time-stamp plus the specified number of milliseconds.
*
* @param time an opaque time-stamp
* @param millis milliseconds to add
* @return a new opaque time-stamp
*/
static long plusMillis(long time, long millis) {
return CLOCK.plusMillis0(time, millis);
}
long plusMillis0(long time, long millis);
/**
* Get the TimeUnit the ClockSource is denominated in.
* @return
*/
static TimeUnit getSourceTimeUnit() {
return CLOCK.getSourceTimeUnit0();
}
TimeUnit getSourceTimeUnit0();
/**
* Get a String representation of the elapsed time in appropriate magnitude terminology.
*
* @param startTime an opaque time-stamp
* @param endTime an opaque time-stamp
* @return a string representation of the elapsed time interval
*/
static String elapsedDisplayString(long startTime, long endTime) {
return CLOCK.elapsedDisplayString0(startTime, endTime);
}
default String elapsedDisplayString0(long startTime, long endTime) {
long elapsedNanos = elapsedNanos0(startTime, endTime);
StringBuilder sb = new StringBuilder(elapsedNanos < 0 ? "-" : "");
elapsedNanos = Math.abs(elapsedNanos);
for (TimeUnit unit : TIMEUNITS_DESCENDING) {
long converted = unit.convert(elapsedNanos, NANOSECONDS);
if (converted > 0) {
sb.append(converted).append(TIMEUNIT_DISPLAY_VALUES[unit.ordinal()]);
elapsedNanos -= NANOSECONDS.convert(converted, unit);
}
}
return sb.toString();
}
TimeUnit[] TIMEUNITS_DESCENDING = {DAYS, HOURS, MINUTES, SECONDS, MILLISECONDS, MICROSECONDS, NANOSECONDS};
String[] TIMEUNIT_DISPLAY_VALUES = {"ns", "µs", "ms", "s", "m", "h", "d"};
/**
* Factory class used to create a platform-specific ClockSource.
*/
class Factory
{
private static ClockSource create() {
String os = System.getProperty("os.name");
if ("Mac OS X".equals(os)) {
return new MillisecondClockSource();
}
return new NanosecondClockSource();
}
}
final class MillisecondClockSource implements ClockSource
{
/** {@inheritDoc} */
@Override
public long currentTime0() {
return System.currentTimeMillis();
}
/** {@inheritDoc} */
@Override
public long elapsedMillis0(final long startTime) {
return System.currentTimeMillis() - startTime;
}
/** {@inheritDoc} */
@Override
public long elapsedMillis0(final long startTime, final long endTime) {
return endTime - startTime;
}
/** {@inheritDoc} */
@Override
public long elapsedNanos0(final long startTime) {
return MILLISECONDS.toNanos(System.currentTimeMillis() - startTime);
}
/** {@inheritDoc} */
@Override
public long elapsedNanos0(final long startTime, final long endTime) {
return MILLISECONDS.toNanos(endTime - startTime);
}
/** {@inheritDoc} */
@Override
public long toMillis0(final long time) {
return time;
}
/** {@inheritDoc} */
@Override
public long toNanos0(final long time) {
return MILLISECONDS.toNanos(time);
}
/** {@inheritDoc} */
@Override
public long plusMillis0(final long time, final long millis) {
return time + millis;
}
/** {@inheritDoc} */
@Override
public TimeUnit getSourceTimeUnit0() {
return MILLISECONDS;
}
}
class NanosecondClockSource implements ClockSource
{
/** {@inheritDoc} */
@Override
public long currentTime0() {
return System.nanoTime();
}
/** {@inheritDoc} */
@Override
public long toMillis0(final long time) {
return NANOSECONDS.toMillis(time);
}
/** {@inheritDoc} */
@Override
public long toNanos0(final long time) {
return time;
}
/** {@inheritDoc} */
@Override
public long elapsedMillis0(final long startTime) {
return NANOSECONDS.toMillis(System.nanoTime() - startTime);
}
/** {@inheritDoc} */
@Override
public long elapsedMillis0(final long startTime, final long endTime) {
return NANOSECONDS.toMillis(endTime - startTime);
}
/** {@inheritDoc} */
@Override
public long elapsedNanos0(final long startTime) {
return System.nanoTime() - startTime;
}
/** {@inheritDoc} */
@Override
public long elapsedNanos0(final long startTime, final long endTime) {
return endTime - startTime;
}
/** {@inheritDoc} */
@Override
public long plusMillis0(final long time, final long millis) {
return time + MILLISECONDS.toNanos(millis);
}
/** {@inheritDoc} */
@Override
public TimeUnit getSourceTimeUnit0() {
return NANOSECONDS;
}
}
}
HikariCP-HikariCP-2.7.1/src/main/java/com/zaxxer/hikari/util/ConcurrentBag.java 0000775 0000000 0000000 00000032227 13154316420 0027171 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013, 2014 Brett Wooldridge
*
* 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.
*/
package com.zaxxer.hikari.util;
import static java.lang.Thread.yield;
import static java.util.concurrent.TimeUnit.MICROSECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.locks.LockSupport.parkNanos;
import static com.zaxxer.hikari.util.ClockSource.currentTime;
import static com.zaxxer.hikari.util.ClockSource.elapsedNanos;
import static com.zaxxer.hikari.util.ConcurrentBag.IConcurrentBagEntry.STATE_IN_USE;
import static com.zaxxer.hikari.util.ConcurrentBag.IConcurrentBagEntry.STATE_NOT_IN_USE;
import static com.zaxxer.hikari.util.ConcurrentBag.IConcurrentBagEntry.STATE_REMOVED;
import static com.zaxxer.hikari.util.ConcurrentBag.IConcurrentBagEntry.STATE_RESERVED;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.zaxxer.hikari.util.ConcurrentBag.IConcurrentBagEntry;
/**
* This is a specialized concurrent bag that achieves superior performance
* to LinkedBlockingQueue and LinkedTransferQueue for the purposes of a
* connection pool. It uses ThreadLocal storage when possible to avoid
* locks, but resorts to scanning a common collection if there are no
* available items in the ThreadLocal list. Not-in-use items in the
* ThreadLocal lists can be "stolen" when the borrowing thread has none
* of its own. It is a "lock-less" implementation using a specialized
* AbstractQueuedLongSynchronizer to manage cross-thread signaling.
*
* Note that items that are "borrowed" from the bag are not actually
* removed from any collection, so garbage collection will not occur
* even if the reference is abandoned. Thus care must be taken to
* "requite" borrowed objects otherwise a memory leak will result. Only
* the "remove" method can completely remove an object from the bag.
*
* @author Brett Wooldridge
*
* @param the templated type to store in the bag
*/
public class ConcurrentBag implements AutoCloseable
{
private static final Logger LOGGER = LoggerFactory.getLogger(ConcurrentBag.class);
private final CopyOnWriteArrayList sharedList;
private final boolean weakThreadLocals;
private final ThreadLocal> threadList;
private final IBagStateListener listener;
private final AtomicInteger waiters;
private volatile boolean closed;
private final SynchronousQueue handoffQueue;
public interface IConcurrentBagEntry
{
int STATE_NOT_IN_USE = 0;
int STATE_IN_USE = 1;
int STATE_REMOVED = -1;
int STATE_RESERVED = -2;
boolean compareAndSet(int expectState, int newState);
void setState(int newState);
int getState();
}
public interface IBagStateListener
{
void addBagItem(int waiting);
}
/**
* Construct a ConcurrentBag with the specified listener.
*
* @param listener the IBagStateListener to attach to this bag
*/
public ConcurrentBag(final IBagStateListener listener)
{
this.listener = listener;
this.weakThreadLocals = useWeakThreadLocals();
this.handoffQueue = new SynchronousQueue<>(true);
this.waiters = new AtomicInteger();
this.sharedList = new CopyOnWriteArrayList<>();
if (weakThreadLocals) {
this.threadList = ThreadLocal.withInitial(() -> new ArrayList<>(16));
}
else {
this.threadList = ThreadLocal.withInitial(() -> new FastList<>(IConcurrentBagEntry.class, 16));
}
}
/**
* The method will borrow a BagEntry from the bag, blocking for the
* specified timeout if none are available.
*
* @param timeout how long to wait before giving up, in units of unit
* @param timeUnit a TimeUnit determining how to interpret the timeout parameter
* @return a borrowed instance from the bag or null if a timeout occurs
* @throws InterruptedException if interrupted while waiting
*/
public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException
{
// Try the thread-local list first
final List
HikariCP It's Faster.Hi·ka·ri [hi·ka·'lē] (Origin: Japanese): light; ray.
Anaylsis of HikariCP v2.6, in comparison to other pools, in relation to a unique "spike demand" load.
The customer's environment imposed a high cost of new connection acquisition, and a requirement for a dynamically-sized pool, but yet a need for responsiveness to request spikes. Read about the spike demand handling [here](https://github.com/brettwooldridge/HikariCP/blob/dev/documents/Welcome-To-The-Jungle.md).
AKA *"What you probably didn't know about connection pool sizing"*. Watch a video from the Oracle Real-world Performance group, and learn about why connection pools do not need to be sized as large as they often are. In fact, oversized connection pools have a clear and demonstrable *negative* impact on performance; a 50x difference in the case of the Oracle demonstration. [Read on to find out](https://github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing).
We'd like to thank the guys over at WIX for the unsolicited and deep write-up about HikariCP on their [engineering blog](http://engineering.wix.com/2015/04/28/how-does-hikaricp-compare-to-other-connection-pools/). Take a look if you have time.
![][spacer]
![][spacer]
![][spacer]
![][spacer]
![][spacer]
![][spacer]
![][spacer]
![][spacer]
![][spacer]
![][spacer]
-------------------------------------------------------------------------------------
* Images on this page are Trademarked and Copyrighted by their respective rights holders.
* Images on this page are used without express permission, and do not constitute an endorsement of HikariCP. If you are a trademark or copyright holder and wish an image to be removed from this page, please open a request in the issue tracker.
[spacer]: https://github.com/brettwooldridge/HikariCP/wiki/space60x1.gif
HikariCP-HikariCP-2.7.1/documents/Welcome-To-The-Jungle.md 0000664 0000000 0000000 00000020136 13154316420 0023042 0 ustar 00root root 0000000 0000000 
Microbenchmarks are great at measuring performance "in the small"; for example, measuring the performance of individual methods. But good results do not necessarily translate into macro-scale performance. Real world access patterns and demand loads often run into deeper, systemic, architectural design issues that cannot be discerned at the micro level.
HikariCP has over 100K users, so from time to time we are approached with challenges encountered "in the wild". Recently, one such challenge led to a deeper investigation: ***Spike Demand***.
### The Challenge
The user has an environment where connection creation is expensive, on the order of 150ms; and yet queries typically execute in ~2ms. Long connection setup times can be the result of various factors, alone or in combination: DNS resolution times, encrypted connections with strong encryption (2048/4096 bit), external authentication, database server load, etc.
*Generally speaking, for the best performance in response to spike demands, HikariCP recommends a fixed-size pool.*
Unfortunately, the user's application is also in an environment where many other applications are connected to the same database, and therefore dynamically-sized pools are desirable -- where idle applications are allowed to give some of up their connections. The user is running the application with HikariCP configured as ``minimumIdle=5``.
In this environment, the application has periods of quiet, as well as sudden spikes of requests, and periods of sustained activity. The combination of high connection setup times, a dynamically-sized pool requirement, and spike demands is just about the worst case scenario for a connection pool.
The questions ultimately were these:
> * If the pool is sitting idle with 5 connections, and is suddenly hit with 50 requests, what should happen?
> * Given that a each new connection is going to take 150ms to establish, and given that each request can ultimately be satisfied in ~2ms, shouldn't even a single one of the idle connections be able to handle all the of the requests in ~100ms anyway?
> * So, why is the pool size growing [so much]?
We thought these were interesting questions, and HikariCP was indeed creating more connections than we expected...
### 3, 2, 1 ... Go!
In order to explore these questions, we built a simulation and started measuring. The simulation harness [code is here](https://github.com/brettwooldridge/HikariCP-benchmark/blob/master/src/test/java/com/zaxxer/hikari/benchmark/SpikeLoadTest.java).
The constraints are simple:
* Connection establishment takes 150ms.
* Query execution takes 2ms.
* The maximum pool size is 50.
* The minumum idle connections is 5.
And the simulation is fairly simple:
* Everything is quiet, and then ... Boom! ... 50 threads, at once, wanting a connection and to execute a query.
* Take measurements every 250μs (microseconds).
### Results
After running HikariCP through the simulation, tweaking the code (ultimately a one-line change), and satisfying ourselves that the behavior is as we would wish, we ran a few other pools through the simulation.
The code was run as follows:
```
bash$ ./spiketest.sh 150