This flag is required when you want to use asynchronous connection retrieval.
</p>
</attribute>
+
+ <attribute name="abandonWhenPercentageFull" required="false">
+ <p>(int) Connections that have been abandoned (timed out) wont get closed and reported up unless
+ the number of connections in use are above the percentage defined by <code>abandonWhenPercentageFull</code>.
+ The value should be between 0-100.
+ The default value is <code>0</code>, which implies that connections are eligible for closure as soon
+ as <code>removeAbandonedTimeout</code> has been reached.</p>
+ </attribute>
+
<attribute name="useEquals" required="false">
<p>(boolean) Set to true if you wish the <code>ProxyConnection</code> class to use <code>String.equals</code> instead of
<code>==</code> when comparing method names. This property does not apply to added interceptors as those are configured individually.
<attributes>
</attributes>
</subsection>
+ <subsection name="org.apache.tomcat.jdbc.pool.interceptor.ResetAbandonedTimer">
+ <p>
+ The abandoned timer starts when a connection is checked out from the pool.
+ This means if you have a 30second timeout and run 10x10second queries using the connection
+ it will be marked abandoned and potentially reclaimed depending on the <code>abandonWhenPercentageFull</code>
+ attribute.
+ Using this interceptor it will reset the checkout timer every time you perform an operation on the connection or execute a
+ query successfully.
+ </p>
+ <attributes>
+ </attributes>
+ </subsection>
</section>
<section name="Code Example">
} //end if
} //checkIn
+ public boolean shouldAbandon() {
+ if (poolProperties.getAbandonWhenPercentageFull()==0) return true;
+ float used = (float)busy.size();
+ float max = (float)poolProperties.getMaxActive();
+ float perc = (float)poolProperties.getAbandonWhenPercentageFull();
+ System.out.println("Abandon rate:"+(used/max*100f));
+ return (used/max*100f)>=perc;
+ }
+
public void checkAbandoned() {
try {
if (busy.size()==0) return;
+ if (!shouldAbandon()) return;
Iterator<PooledConnection> locked = busy.iterator();
while (locked.hasNext()) {
PooledConnection con = locked.next();
}
}
+ public int getAbandonWhenPercentageFull() {
+ try {
+ return createPool().getPoolProperties().getAbandonWhenPercentageFull();
+ }catch (SQLException x) {
+ throw new RuntimeException(x);
+ }
+ }
+
public boolean isTestOnBorrow() {
try {
return createPool().getPoolProperties().isTestOnBorrow();
protected final static String PROP_REMOVEABANDONED = "removeAbandoned";
protected final static String PROP_REMOVEABANDONEDTIMEOUT = "removeAbandonedTimeout";
protected final static String PROP_LOGABANDONED = "logAbandoned";
+ protected final static String PROP_ABANDONWHENPERCENTAGEFULL = "abandonWhenPercentageFull";
protected final static String PROP_POOLPREPAREDSTATEMENTS = "poolPreparedStatements";
protected final static String PROP_MAXOPENPREPAREDSTATEMENTS = "maxOpenPreparedStatements";
PROP_JMX_ENABLED,
PROP_FAIR_QUEUE,
PROP_USE_EQUALS,
- OBJECT_NAME
+ OBJECT_NAME,
+ PROP_ABANDONWHENPERCENTAGEFULL
};
// -------------------------------------------------- ObjectFactory Methods
if (value != null) {
poolProperties.setName(ObjectName.quote(value));
}
-
- return poolProperties;
+ value = properties.getProperty(PROP_ABANDONWHENPERCENTAGEFULL);
+ if (value != null) {
+ poolProperties.setAbandonWhenPercentageFull(Integer.parseInt(value));
+ }
+
+ return poolProperties;
}
/**
protected boolean jmxEnabled = true;
protected String initSQL;
protected boolean testOnConnect =false;
- private String jdbcInterceptors=null;
- private boolean fairQueue = true;
- private boolean useEquals = false;
+ protected String jdbcInterceptors=null;
+ protected boolean fairQueue = true;
+ protected boolean useEquals = false;
+ protected int abandonWhenPercentageFull = 0;
private InterceptorDefinition[] interceptors = null;
+ public void setAbandonWhenPercentageFull(int percentage) {
+ if (percentage<0) abandonWhenPercentageFull = 0;
+ else if (percentage>100) abandonWhenPercentageFull = 100;
+ else abandonWhenPercentageFull = percentage;
+ }
+
+ public int getAbandonWhenPercentageFull() {
+ return abandonWhenPercentageFull;
+ }
+
public boolean isFairQueue() {
return fairQueue;
}
super();
}
-
/**
* Invoked when prepareStatement has been called and completed.
* @param sql - the string used to prepare the statement with
--- /dev/null
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.tomcat.jdbc.pool.interceptor;
+
+import java.lang.reflect.Method;
+
+import org.apache.tomcat.jdbc.pool.JdbcInterceptor;
+import org.apache.tomcat.jdbc.pool.PooledConnection;
+import org.apache.tomcat.jdbc.pool.ProxyConnection;
+
+/**
+ * Class that resets the abandoned timer on any activity on the
+ * Connection or any successful query executions
+ * @author fhanik
+ *
+ */
+public class ResetAbandonedTimer extends AbstractQueryReport {
+
+ public ResetAbandonedTimer() {
+ // TODO Auto-generated constructor stub
+ }
+
+ public boolean resetTimer() {
+ boolean result = false;
+ JdbcInterceptor interceptor = this.getNext();
+ while (interceptor!=null && result==false) {
+ if (interceptor instanceof ProxyConnection) {
+ PooledConnection con = ((ProxyConnection)interceptor).getConnection();
+ if (con!=null) {
+ con.setTimestamp(System.currentTimeMillis());
+ result = true;
+ } else {
+ break;
+ }
+ }
+ interceptor = interceptor.getNext();
+ }
+ return result;
+ }
+
+
+
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ // TODO Auto-generated method stub
+ Object result = super.invoke(proxy, method, args);
+ resetTimer();
+ return result;
+ }
+
+ @Override
+ protected void prepareCall(String query, long time) {
+ resetTimer();
+ }
+
+ @Override
+ protected void prepareStatement(String sql, long time) {
+ resetTimer();
+
+ }
+
+ @Override
+ public void closeInvoked() {
+ resetTimer();
+ }
+
+ @Override
+ protected String reportQuery(String query, Object[] args, String name,long start, long delta) {
+ resetTimer();
+ return super.reportQuery(query, args, name, start, delta);
+ }
+
+ @Override
+ protected String reportSlowQuery(String query, Object[] args, String name,long start, long delta) {
+ resetTimer();
+ return super.reportSlowQuery(query, args, name, start, delta);
+ }
+}
public int getWaitCount() {
return pool.getWaitCount();
}
+ public int getAbandonWhenPercentageFull() {
+ return pool.getPoolProperties().getAbandonWhenPercentageFull();
+ }
}
public String getJdbcInterceptors();
+ public int getAbandonWhenPercentageFull();
+
}
projects / tomcat7.0 / commitdiff