/*
* GeoTools - The Open Source Java GIS Toolkit
* http://geotools.org
*
* (C) 2002-2008, Open Source Geospatial Foundation (OSGeo)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
*/
package org.geotools.arcsde.session;
import java.io.IOException;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.pool.BasePoolableObjectFactory;
import org.apache.commons.pool.impl.GenericObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool.Config;
import org.geotools.arcsde.ArcSdeException;
import org.geotools.arcsde.logging.Loggers;
import com.esri.sde.sdk.client.SeException;
import com.esri.sde.sdk.client.SeRelease;
/**
* Maintains <code>SeConnection</code>'s for a single set of connection properties (for instance: by
* server, port, user and password) in a pool to recycle used connections.
* <p>
* We are making use of an Apache Commons ObjectPool to maintain connections. This connection pool
* is configurable in the sense that some parameters can be passed to establish the pooling policy.
* To pass parameters to the connection pool, you should set properties in the parameters Map passed
* to SdeDataStoreFactory.createDataStore, which will invoke SdeConnectionPoolFactory to get the SDE
* instance's pool singleton. That instance singleton will be created with the preferences passed
* the first time createDataStore is called for a given SDE instance/user, if subsequent calls
* change that preferences, they will be ignored.
* </p>
* <p>
* The expected optional parameters that you can set up in the argument Map for createDataStore are:
* <ul>
* <li>pool.minConnections Integer, tells the minimum number of open connections the pool will
* maintain opened</li>
* <li>pool.maxConnections Integer, tells the maximum number of open connections the pool will
* create and maintain opened</li>
* <li>pool.timeOut Integer, tells how many milliseconds a calling thread is guaranteed to wait
* before getConnection() throws an UnavailableArcSDEConnectionException</li>
* </ul>
* </p>
*
* @author Gabriel Roldan
* @version $Id$
*/
class SessionPool implements ISessionPool {
private static final Logger LOGGER = Loggers.getLogger("org.geotools.arcsde.session");
protected static final Level INFO_LOG_LEVEL = Level.WARNING;
private SeConnectionFactory seConnectionFactory;
/** this connection pool connection's parameters */
protected ArcSDEConnectionConfig config;
/** Apache commons-pool used to pool arcsde connections */
private GenericObjectPool pool;
private final Queue<Session> openSessionsNonTransactional = new LinkedList<Session>();// new
// ConcurrentLinkedQueue<Session>();
/**
* Creates a new SessionPool object for the given config.
*
* @param config
* holds connection options such as server, user and password, as well as tuning
* options as maximum number of connections allowed
* @throws IOException
* If connection could not be established
* @throws NullPointerException
* If config is null
*/
protected SessionPool(ArcSDEConnectionConfig config) throws IOException {
if (config == null) {
throw new NullPointerException("parameter config can't be null");
}
this.config = config;
LOGGER.fine("populating ArcSDE connection pool");
this.seConnectionFactory = createConnectionFactory();
final int minConnections = config.getMinConnections().intValue();
final int maxConnections = config.getMaxConnections().intValue();
if (minConnections > maxConnections) {
throw new IllegalArgumentException("pool.minConnections > pool.maxConnections");
}
{// configure connection pool
Config poolCfg = new Config();
// pool upper limit
poolCfg.maxActive = config.getMaxConnections().intValue();
// minimum number of idle objects. MAKE SURE this is 0, otherwise the pool will start
// trying to create connections permanently even if there's a connection failure,
// ultimately leading to the exhaustion of resources
poolCfg.minIdle = 0;
// how many connections may be idle at any time? -1 = no limit. We're running an
// eviction thread to take care of idle connections (see minEvictableIdleTimeMillis and
// timeBetweenEvictionRunsMillis)
poolCfg.maxIdle = -1;
// When reached the pool upper limit, block and wait for an idle connection for maxWait
// milliseconds before failing
poolCfg.maxWait = config.getConnTimeOut().longValue();
if (poolCfg.maxWait > 0) {
poolCfg.whenExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_BLOCK;
} else {
poolCfg.whenExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_FAIL;
}
// check connection health at borrowObject()?
poolCfg.testOnBorrow = true;
// check connection health at returnObject()?
poolCfg.testOnReturn = false;
// check periodically the health of idle connections and discard them if can't be
// validated?
poolCfg.testWhileIdle = false;
// check health of idle connections every 30 seconds
// /poolCfg.timeBetweenEvictionRunsMillis = 30000;
// drop connections that have been idle for at least 5 minutes
poolCfg.minEvictableIdleTimeMillis = 5 * 60 * 1000;
pool = new GenericObjectPool(seConnectionFactory, poolCfg);
LOGGER.fine("Created ArcSDE connection pool for " + config);
}
ISession[] preload = new ISession[minConnections];
try {
for (int i = 0; i < minConnections; i++) {
preload[i] = (ISession) pool.borrowObject();
if (i == 0) {
SeRelease seRelease = preload[i].getRelease();
String sdeDesc = seRelease.getDesc();
int major = seRelease.getMajor();
int minor = seRelease.getMinor();
int bugFix = seRelease.getBugFix();
String desc = "ArcSDE " + major + "." + minor + "." + bugFix + " " + sdeDesc;
LOGGER.fine("Connected to " + desc);
}
}
for (int i = 0; i < minConnections; i++) {
pool.returnObject(preload[i]);
}
} catch (Exception e) {
close();
if (e instanceof IOException) {
throw (IOException) e;
}
throw (IOException) new IOException().initCause(e);
}
}
/**
* SeConnectionFactory used to create {@link ISession} instances for the pool.
* <p>
* Subclass may overide to customize this behaviour.
* </p>
*
* @return SeConnectionFactory.
*/
protected SeConnectionFactory createConnectionFactory() {
return new SeConnectionFactory(this.config);
}
/*
* (non-Javadoc)
*
* @see org.geotools.arcsde.session.ISessionPool#getPoolSize()
*/
public int getPoolSize() {
checkOpen();
return pool.getMaxActive();
}
/*
* (non-Javadoc)
*
* @see org.geotools.arcsde.session.ISessionPool#close()
*/
public void close() {
if (pool != null) {
try {
pool.close();
pool = null;
LOGGER.fine("SDE connection pool closed. ");
} catch (Exception e) {
LOGGER.log(Level.WARNING, "Closing pool: " + e.getMessage(), e);
}
}
}
/*
* (non-Javadoc)
*
* @see org.geotools.arcsde.session.ISessionPool#isClosed()
*/
public boolean isClosed() {
return pool == null;
}
private void checkOpen() throws IllegalStateException {
if (isClosed()) {
throw new IllegalStateException("This session pool is closed");
}
}
/**
* Ensures proper closure of connection pool at this object's finalization stage.
*/
@Override
protected void finalize() {
close();
}
/**
* @see org.geotools.arcsde.session.ISessionPool#getAvailableCount()
*/
public synchronized int getAvailableCount() {
checkOpen();
return pool.getMaxActive() - pool.getNumActive();
}
/**
* @see org.geotools.arcsde.session.ISessionPool#getInUseCount()
*/
public int getInUseCount() {
checkOpen();
return pool.getNumActive();
}
/**
* @see org.geotools.arcsde.session.ISessionPool#getSession()
*/
public ISession getSession() throws IOException, UnavailableConnectionException {
return getSession(true);
}
/**
* Return the session Object to the ConnectionPool.
* Method must be synchronized, in order to prevent SessionPool
* from opening more connections than in max.Connection defined under
* heavy load
*
* @param session
* @throws Exception
*/
public synchronized void returnObject(Session session) throws Exception {
openSessionsNonTransactional.remove(session);
pool.returnObject(session);
}
/**
* @see org.geotools.arcsde.session.ISessionPool#getSession(boolean)
*/
public ISession getSession(final boolean transactional) throws IOException,
UnavailableConnectionException {
checkOpen();
try {
Session connection = null;
if (transactional) {
LOGGER.finest("Borrowing session from pool for transactional access");
connection = (Session) pool.borrowObject();
} else {
synchronized (openSessionsNonTransactional) {
try {
if (LOGGER.isLoggable(Level.FINER)) {
LOGGER.finer("Grabbing session from pool on "
+ Thread.currentThread().getName());
}
connection = (Session) pool.borrowObject();
if (LOGGER.isLoggable(Level.FINER)) {
LOGGER.finer("Got session from the pool on "
+ Thread.currentThread().getName());
}
} catch (NoSuchElementException e) {
if (LOGGER.isLoggable(Level.FINER)) {
LOGGER.finer("No available sessions in the pool, falling back to queued session");
}
connection = openSessionsNonTransactional.remove();
}
openSessionsNonTransactional.add(connection);
if (LOGGER.isLoggable(Level.FINER)) {
LOGGER.finer("Got session from the in use queue on "
+ Thread.currentThread().getName());
}
}
}
connection.markActive();
return connection;
} catch (NoSuchElementException e) {
LOGGER.log(Level.WARNING, "Out of connections: " + e.getMessage() + ". Config: "
+ this.config);
throw new UnavailableConnectionException(config.getMaxConnections(), this.config);
} catch (SeException se) {
ArcSdeException sdee = new ArcSdeException(se);
LOGGER.log(Level.WARNING, "ArcSDE error getting connection for " + config, sdee);
throw sdee;
} catch (Exception e) {
LOGGER.log(Level.WARNING, "Unknown problem getting connection: " + e.getMessage(), e);
throw (IOException) new IOException(
"Unknown problem fetching connection from connection pool").initCause(e);
}
}
/*
* (non-Javadoc)
*
* @see org.geotools.arcsde.session.ISessionPool#getConfig()
*/
public ArcSDEConnectionConfig getConfig() {
return this.config;
}
/**
* PoolableObjectFactory intended to be used by a Jakarta's commons-pool objects pool, that
* provides ArcSDE's SeConnections.
*
* @author Gabriel Roldan, Axios Engineering
* @version $Id$
*/
private class SeConnectionFactory extends BasePoolableObjectFactory {
private ArcSDEConnectionConfig config;
/**
* Creates a new SeConnectionFactory object.
*
* @param config
*/
public SeConnectionFactory(ArcSDEConnectionConfig config) {
super();
this.config = config;
}
/**
* Called whenever a new instance is needed.
* <p>
* The implementation for this method needs to be synchronized in order to make sure no two
* {@code SeConnection} instances are created at the same time. Otherwise, when that happens
* under load, SeConnection's constructor uses to throw a nasty
* {@code NegativeArraySizeException}.
* </p>
*
* @return a newly created <code>SeConnection</code>
* @throws SeException
* if the connection can't be created
*/
@Override
public synchronized Object makeObject() throws IOException {
ISession seConn;
seConn = new Session(SessionPool.this, config);
return seConn;
}
@Override
public void passivateObject(Object obj) {
LOGGER.finest(" passivating connection " + obj);
final Session conn = (Session) obj;
conn.markInactive();
}
/**
* is invoked in an implementation-specific fashion to determine if an instance is still
* valid to be returned by the pool. It will only be invoked on an "activated" instance.
*
* @param an
* instance of {@link Session} maintained by this pool.
* @return <code>true</code> if the connection is still alive and operative (checked by
* asking its user name), <code>false</code> otherwise.
*/
@Override
public boolean validateObject(Object obj) {
ISession session = (ISession) obj;
boolean valid = !session.isClosed();
// MAKE PROPER VALIDITY CHECK HERE as for GEOT-1273
if (valid) {
try {
if (LOGGER.isLoggable(Level.FINEST)) {
LOGGER.finest(" Validating SDE Connection " + session);
}
/*
* Validate the connection's health with testServer instead of getUser. The
* former is lighter weight, getUser() forced a server round trip and under
* heavy concurrency ate about 30% the time
*/
session.testServer();
} catch (IOException e) {
LOGGER.info("Can't validate SeConnection, discarding it: " + session
+ ". Reason: " + e.getMessage());
valid = false;
}
}
return valid;
}
/**
* is invoked on every instance when it is being "dropped" from the pool (whether due to the
* response from validateObject, or for reasons specific to the pool implementation.)
*
* @param obj
* an instance of {@link Session} maintained by this pool.
*/
@Override
public void destroyObject(Object obj) {
Session conn = (Session) obj;
conn.destroy();
}
}
@Override
public String toString() {
StringBuilder ret = new StringBuilder(getClass().getSimpleName());
ret.append("[config=").append(getConfig());
if (pool == null) {
ret.append("[Session pool is disposed]");
} else {
ret.append("[ACTIVE: ");
ret.append(pool.getNumActive() + "/" + ((GenericObjectPool) pool).getMaxActive());
ret.append(" INACTIVE: ");
ret.append(pool.getNumIdle() + "/" + ((GenericObjectPool) pool).getMaxIdle() + "]");
}
ret.append("]");
return ret.toString();
}
}