Applied patch from Aaron Mulder (ammulder@alumni.princeton.edu) that fixes
jdbc datasource support for jdk1.4/jdbc3 Modified Files: jdbc/build.xml jdbc/org/postgresql/Driver.java.in jdbc/org/postgresql/jdbc2/optional/BaseDataSource.java jdbc/org/postgresql/jdbc2/optional/PGObjectFactory.java jdbc/org/postgresql/jdbc2/optional/PooledConnectionImpl.java jdbc/org/postgresql/jdbc2/optional/PoolingDataSource.java jdbc/org/postgresql/test/jdbc2/optional/BaseDataSourceTest.java jdbc/org/postgresql/test/jdbc2/optional/OptionalTestSuite.java jdbc/org/postgresql/test/jdbc3/Jdbc3TestSuite.java Added Files: jdbc/org/postgresql/jdbc3/Jdbc3ConnectionPool.java jdbc/org/postgresql/jdbc3/Jdbc3ObjectFactory.java jdbc/org/postgresql/jdbc3/Jdbc3PooledConnection.java jdbc/org/postgresql/jdbc3/Jdbc3PoolingDataSource.java jdbc/org/postgresql/jdbc3/Jdbc3SimpleDataSource.java jdbc/org/postgresql/test/jdbc2/optional/PoolingDataSourceTest.java jdbc/org/postgresql/test/jdbc3/Jdbc3ConnectionPoolTest.java jdbc/org/postgresql/test/jdbc3/Jdbc3PoolingDataSourceTest.java jdbc/org/postgresql/test/jdbc3/Jdbc3SimpleDataSourceTest.java jdbc/org/postgresql/test/util/MiniJndiContext.java jdbc/org/postgresql/test/util/MiniJndiContextFactory.java
This commit is contained in:
Barry Lind
parent
65bf5a39e0
commit
7bf1c8b0ad
@ -6,7 +6,7 @@
|
||||
|
||||
This file now requires Ant 1.4.1. 2002-04-18
|
||||
|
||||
$Header: /cvsroot/pgsql/src/interfaces/jdbc/Attic/build.xml,v 1.28 2002/08/14 20:35:39 barry Exp $
|
||||
$Header: /cvsroot/pgsql/src/interfaces/jdbc/Attic/build.xml,v 1.29 2002/09/25 07:01:30 barry Exp $
|
||||
|
||||
-->
|
||||
|
||||
@ -262,6 +262,7 @@
|
||||
<target name="testjdbc2optional" depends="jar" if="jdbc2optionaltests">
|
||||
<javac srcdir="${srcdir}" destdir="${builddir}" debug="${debug}">
|
||||
<include name="${package}/test/jdbc2/optional/**" />
|
||||
<include name="${package}/test/util/**" />
|
||||
</javac>
|
||||
<java fork="yes" classname="junit.${junit.ui}.TestRunner" taskname="junit" failonerror="true">
|
||||
<arg value="org.postgresql.test.jdbc2.optional.OptionalTestSuite" />
|
||||
@ -278,6 +279,7 @@
|
||||
<target name="testjdbc3" depends="jar" if="jdbc3tests">
|
||||
<javac srcdir="${srcdir}" destdir="${builddir}" debug="${debug}">
|
||||
<include name="${package}/test/jdbc3/*" />
|
||||
<include name="${package}/test/util/*" />
|
||||
</javac>
|
||||
<java fork="yes" classname="junit.${junit.ui}.TestRunner" taskname="junit" failonerror="true">
|
||||
<arg value="org.postgresql.test.jdbc3.Jdbc3TestSuite" />
|
||||
|
||||
@ -446,6 +446,6 @@ public class Driver implements java.sql.Driver
|
||||
}
|
||||
|
||||
//The build number should be incremented for every new build
|
||||
private static int m_buildNumber = 105;
|
||||
private static int m_buildNumber = 106;
|
||||
|
||||
}
|
||||
|
||||
@ -8,7 +8,7 @@ import java.sql.*;
|
||||
* Base class for data sources and related classes.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.2 $
|
||||
* @version $Revision: 1.3 $
|
||||
*/
|
||||
public abstract class BaseDataSource implements Referenceable
|
||||
{
|
||||
@ -233,9 +233,18 @@ public abstract class BaseDataSource implements Referenceable
|
||||
return "jdbc:postgresql://" + serverName + (portNumber == 0 ? "" : ":" + portNumber) + "/" + databaseName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a reference using the appropriate object factory. This
|
||||
* implementation uses the JDBC 2 optional package object factory.
|
||||
*/
|
||||
protected Reference createReference()
|
||||
{
|
||||
return new Reference(getClass().getName(), PGObjectFactory.class.getName(), null);
|
||||
}
|
||||
|
||||
public Reference getReference() throws NamingException
|
||||
{
|
||||
Reference ref = new Reference(getClass().getName(), PGObjectFactory.class.getName(), null);
|
||||
Reference ref = createReference();
|
||||
ref.add(new StringRefAddr("serverName", serverName));
|
||||
if (portNumber != 0)
|
||||
{
|
||||
|
||||
@ -13,7 +13,7 @@ import java.util.Hashtable;
|
||||
* consistent.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.2 $
|
||||
* @version $Revision: 1.3 $
|
||||
*/
|
||||
public class PGObjectFactory implements ObjectFactory
|
||||
{
|
||||
@ -81,7 +81,7 @@ public class PGObjectFactory implements ObjectFactory
|
||||
return loadBaseDataSource(cp, ref);
|
||||
}
|
||||
|
||||
private Object loadBaseDataSource(BaseDataSource ds, Reference ref)
|
||||
protected Object loadBaseDataSource(BaseDataSource ds, Reference ref)
|
||||
{
|
||||
ds.setDatabaseName(getProperty(ref, "databaseName"));
|
||||
ds.setPassword(getProperty(ref, "password"));
|
||||
@ -95,7 +95,7 @@ public class PGObjectFactory implements ObjectFactory
|
||||
return ds;
|
||||
}
|
||||
|
||||
private String getProperty(Reference ref, String s)
|
||||
protected String getProperty(Reference ref, String s)
|
||||
{
|
||||
RefAddr addr = ref.get(s);
|
||||
if (addr == null)
|
||||
|
||||
@ -13,7 +13,7 @@ import java.lang.reflect.*;
|
||||
* @see ConnectionPool
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.2 $
|
||||
* @version $Revision: 1.3 $
|
||||
*/
|
||||
public class PooledConnectionImpl implements PooledConnection
|
||||
{
|
||||
@ -26,7 +26,7 @@ public class PooledConnectionImpl implements PooledConnection
|
||||
* Creates a new PooledConnection representing the specified physical
|
||||
* connection.
|
||||
*/
|
||||
PooledConnectionImpl(Connection con, boolean autoCommit)
|
||||
protected PooledConnectionImpl(Connection con, boolean autoCommit)
|
||||
{
|
||||
this.con = con;
|
||||
this.autoCommit = autoCommit;
|
||||
|
||||
@ -33,7 +33,7 @@ import java.sql.SQLException;
|
||||
* <p>This implementation supports JDK 1.3 and higher.</p>
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.2 $
|
||||
* @version $Revision: 1.3 $
|
||||
*/
|
||||
public class PoolingDataSource extends BaseDataSource implements DataSource
|
||||
{
|
||||
@ -45,7 +45,7 @@ public class PoolingDataSource extends BaseDataSource implements DataSource
|
||||
}
|
||||
|
||||
// Additional Data Source properties
|
||||
private String dataSourceName;
|
||||
protected String dataSourceName; // Must be protected for subclasses to sync updates to it
|
||||
private int initialConnections = 0;
|
||||
private int maxConnections = 0;
|
||||
// State variables
|
||||
@ -262,7 +262,7 @@ public class PoolingDataSource extends BaseDataSource implements DataSource
|
||||
* that number of connections will be created. After this method is called,
|
||||
* the DataSource properties cannot be changed. If you do not call this
|
||||
* explicitly, it will be called the first time you get a connection from the
|
||||
* Datasource.
|
||||
* DataSource.
|
||||
* @throws java.sql.SQLException
|
||||
* Occurs when the initialConnections is greater than zero, but the
|
||||
* DataSource is not able to create enough physical connections.
|
||||
@ -271,7 +271,7 @@ public class PoolingDataSource extends BaseDataSource implements DataSource
|
||||
{
|
||||
synchronized (lock)
|
||||
{
|
||||
source = new ConnectionPool();
|
||||
source = createConnectionPool();
|
||||
source.setDatabaseName(getDatabaseName());
|
||||
source.setPassword(getPassword());
|
||||
source.setPortNumber(getPortNumber());
|
||||
@ -285,6 +285,17 @@ public class PoolingDataSource extends BaseDataSource implements DataSource
|
||||
}
|
||||
}
|
||||
|
||||
protected boolean isInitialized() {
|
||||
return initialized;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the appropriate ConnectionPool to use for this DataSource.
|
||||
*/
|
||||
protected ConnectionPool createConnectionPool() {
|
||||
return new ConnectionPool();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a <b>non-pooled</b> connection, unless the user and password are the
|
||||
* same as the default values for this connection pool.
|
||||
@ -358,13 +369,17 @@ public class PoolingDataSource extends BaseDataSource implements DataSource
|
||||
}
|
||||
used = null;
|
||||
}
|
||||
synchronized (dataSources)
|
||||
{
|
||||
dataSources.remove(dataSourceName);
|
||||
}
|
||||
}
|
||||
removeStoredDataSource();
|
||||
}
|
||||
|
||||
/**
|
||||
protected void removeStoredDataSource() {
|
||||
synchronized (dataSources)
|
||||
{
|
||||
dataSources.remove(dataSourceName);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a connection from the pool. Will get an available one if
|
||||
* present, or create a new one if under the max limit. Will
|
||||
* block if all used and a new one would exceed the max.
|
||||
|
||||
@ -0,0 +1,61 @@
|
||||
package org.postgresql.jdbc3;
|
||||
|
||||
import org.postgresql.jdbc2.optional.ConnectionPool;
|
||||
|
||||
import javax.sql.PooledConnection;
|
||||
import javax.naming.Reference;
|
||||
import java.sql.SQLException;
|
||||
|
||||
/**
|
||||
* Jdbc3 implementation of ConnectionPoolDataSource. This is
|
||||
* typically the interface used by an app server to interact
|
||||
* with connection pools provided by a JDBC driver. PostgreSQL
|
||||
* does not support XADataSource, the other common connection
|
||||
* pooling interface (for connections supporting the two-phase
|
||||
* commit protocol).
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@alumni.princeton.edu)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class Jdbc3ConnectionPool extends ConnectionPool
|
||||
{
|
||||
/**
|
||||
* Gets a description of this DataSource.
|
||||
*/
|
||||
public String getDescription()
|
||||
{
|
||||
return "Jdbc3ConnectionPool from " + org.postgresql.Driver.getVersion();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a connection which may be pooled by the app server or middleware
|
||||
* implementation of DataSource.
|
||||
*
|
||||
* @throws java.sql.SQLException
|
||||
* Occurs when the physical database connection cannot be established.
|
||||
*/
|
||||
public PooledConnection getPooledConnection() throws SQLException
|
||||
{
|
||||
return new Jdbc3PooledConnection(getConnection(), isDefaultAutoCommit());
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a connection which may be pooled by the app server or middleware
|
||||
* implementation of DataSource.
|
||||
*
|
||||
* @throws java.sql.SQLException
|
||||
* Occurs when the physical database connection cannot be established.
|
||||
*/
|
||||
public PooledConnection getPooledConnection(String user, String password) throws SQLException
|
||||
{
|
||||
return new Jdbc3PooledConnection(getConnection(user, password), isDefaultAutoCommit());
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a JDBC object factory reference.
|
||||
*/
|
||||
protected Reference createReference()
|
||||
{
|
||||
return new Reference(getClass().getName(), Jdbc3ObjectFactory.class.getName(), null);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,80 @@
|
||||
package org.postgresql.jdbc3;
|
||||
|
||||
import java.util.*;
|
||||
import javax.naming.*;
|
||||
import org.postgresql.jdbc2.optional.PGObjectFactory;
|
||||
|
||||
/**
|
||||
* JDBC3 version of the Object Factory used to recreate objects
|
||||
* from their JNDI references.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@alumni.princeton.edu)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class Jdbc3ObjectFactory extends PGObjectFactory
|
||||
{
|
||||
/**
|
||||
* Dereferences a PostgreSQL DataSource. Other types of references are
|
||||
* ignored.
|
||||
*/
|
||||
public Object getObjectInstance(Object obj, Name name, Context nameCtx,
|
||||
Hashtable environment) throws Exception
|
||||
{
|
||||
Reference ref = (Reference) obj;
|
||||
if (ref.getClassName().equals(Jdbc3SimpleDataSource.class.getName()))
|
||||
{
|
||||
return loadSimpleDataSource(ref);
|
||||
}
|
||||
else if (ref.getClassName().equals(Jdbc3ConnectionPool.class.getName()))
|
||||
{
|
||||
return loadConnectionPool(ref);
|
||||
}
|
||||
else if (ref.getClassName().equals(Jdbc3PoolingDataSource.class.getName()))
|
||||
{
|
||||
return loadPoolingDataSource(ref);
|
||||
}
|
||||
else
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private Object loadPoolingDataSource(Reference ref)
|
||||
{
|
||||
// If DataSource exists, return it
|
||||
String name = getProperty(ref, "dataSourceName");
|
||||
Jdbc3PoolingDataSource pds = Jdbc3PoolingDataSource.getDataSource(name);
|
||||
if (pds != null)
|
||||
{
|
||||
return pds;
|
||||
}
|
||||
// Otherwise, create a new one
|
||||
pds = new Jdbc3PoolingDataSource();
|
||||
pds.setDataSourceName(name);
|
||||
loadBaseDataSource(pds, ref);
|
||||
String min = getProperty(ref, "initialConnections");
|
||||
if (min != null)
|
||||
{
|
||||
pds.setInitialConnections(Integer.parseInt(min));
|
||||
}
|
||||
String max = getProperty(ref, "maxConnections");
|
||||
if (max != null)
|
||||
{
|
||||
pds.setMaxConnections(Integer.parseInt(max));
|
||||
}
|
||||
return pds;
|
||||
}
|
||||
|
||||
private Object loadSimpleDataSource(Reference ref)
|
||||
{
|
||||
Jdbc3SimpleDataSource ds = new Jdbc3SimpleDataSource();
|
||||
return loadBaseDataSource(ds, ref);
|
||||
}
|
||||
|
||||
private Object loadConnectionPool(Reference ref)
|
||||
{
|
||||
Jdbc3ConnectionPool cp = new Jdbc3ConnectionPool();
|
||||
return loadBaseDataSource(cp, ref);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,20 @@
|
||||
package org.postgresql.jdbc3;
|
||||
|
||||
import org.postgresql.jdbc2.optional.PooledConnectionImpl;
|
||||
|
||||
import java.sql.Connection;
|
||||
|
||||
/**
|
||||
* JDBC3 implementation of PooledConnection, which manages
|
||||
* a connection in a connection pool.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@alumni.princeton.edu)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class Jdbc3PooledConnection extends PooledConnectionImpl
|
||||
{
|
||||
Jdbc3PooledConnection(Connection con, boolean autoCommit)
|
||||
{
|
||||
super(con, autoCommit);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,96 @@
|
||||
package org.postgresql.jdbc3;
|
||||
|
||||
import java.util.*;
|
||||
import org.postgresql.jdbc2.optional.PoolingDataSource;
|
||||
import org.postgresql.jdbc2.optional.ConnectionPool;
|
||||
|
||||
import javax.naming.Reference;
|
||||
|
||||
/**
|
||||
* JDBC 3 implementation of a pooling DataSource. This is best
|
||||
* used outside of an application server environment. Application
|
||||
* servers generally prefer to deal with instances of
|
||||
* ConnectionPoolDataSource (see ConnectionPool) or XADataSource
|
||||
* (not available for PostgreSQL).
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@alumni.princeton.edu)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class Jdbc3PoolingDataSource extends PoolingDataSource
|
||||
{
|
||||
/**
|
||||
* Store JDBC3 DataSources in different bucket than JDBC2 DataSources
|
||||
*/
|
||||
private static Map dataSources = new HashMap();
|
||||
|
||||
/**
|
||||
* Store JDBC3 DataSources in different bucket than JDBC2 DataSources
|
||||
*/
|
||||
static Jdbc3PoolingDataSource getDataSource(String name)
|
||||
{
|
||||
return (Jdbc3PoolingDataSource) dataSources.get(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Store JDBC3 DataSources in different bucket than JDBC2 DataSources
|
||||
*/
|
||||
protected void removeStoredDataSource()
|
||||
{
|
||||
synchronized (dataSources)
|
||||
{
|
||||
dataSources.remove(dataSourceName);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Store JDBC3 DataSources in different bucket than JDBC2 DataSources
|
||||
*/
|
||||
public void setDataSourceName(String dataSourceName)
|
||||
{
|
||||
if (isInitialized())
|
||||
{
|
||||
throw new IllegalStateException("Cannot set Data Source properties after DataSource has been used");
|
||||
}
|
||||
if (this.dataSourceName != null && dataSourceName != null && dataSourceName.equals(this.dataSourceName))
|
||||
{
|
||||
return;
|
||||
}
|
||||
synchronized (dataSources)
|
||||
{
|
||||
if (getDataSource(dataSourceName) != null)
|
||||
{
|
||||
throw new IllegalArgumentException("DataSource with name '" + dataSourceName + "' already exists!");
|
||||
}
|
||||
if (this.dataSourceName != null)
|
||||
{
|
||||
dataSources.remove(this.dataSourceName);
|
||||
}
|
||||
this.dataSourceName = dataSourceName;
|
||||
dataSources.put(dataSourceName, this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a JDBC3 object factory reference.
|
||||
*/
|
||||
protected Reference createReference()
|
||||
{
|
||||
return new Reference(getClass().getName(), Jdbc3ObjectFactory.class.getName(), null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a JDBC3 ConnectionPool to use with this DataSource.
|
||||
*/
|
||||
protected ConnectionPool createConnectionPool()
|
||||
{
|
||||
return new Jdbc3ConnectionPool();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a description of this DataSource.
|
||||
*/
|
||||
public String getDescription()
|
||||
{
|
||||
return "JDBC3 Pooling DataSource from " + org.postgresql.Driver.getVersion();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,30 @@
|
||||
package org.postgresql.jdbc3;
|
||||
|
||||
import org.postgresql.jdbc2.optional.SimpleDataSource;
|
||||
|
||||
import javax.naming.Reference;
|
||||
|
||||
/**
|
||||
* JDBC3 implementation of a non-pooling DataSource.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@alumni.princeton.edu)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class Jdbc3SimpleDataSource extends SimpleDataSource
|
||||
{
|
||||
/**
|
||||
* Generates a JDBC3 object factory reference.
|
||||
*/
|
||||
protected Reference createReference()
|
||||
{
|
||||
return new Reference(getClass().getName(), Jdbc3ObjectFactory.class.getName(), null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a description of this DataSource.
|
||||
*/
|
||||
public String getDescription()
|
||||
{
|
||||
return "JDBC3 Non-Pooling DataSource from " + org.postgresql.Driver.getVersion();
|
||||
}
|
||||
}
|
||||
@ -2,10 +2,11 @@ package org.postgresql.test.jdbc2.optional;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
import org.postgresql.test.TestUtil;
|
||||
import org.postgresql.jdbc2.optional.SimpleDataSource;
|
||||
import org.postgresql.jdbc2.optional.BaseDataSource;
|
||||
|
||||
import java.sql.*;
|
||||
import java.util.*;
|
||||
import javax.naming.*;
|
||||
|
||||
/**
|
||||
* Common tests for all the BaseDataSource implementations. This is
|
||||
@ -15,10 +16,11 @@ import java.sql.*;
|
||||
* tests.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.3 $
|
||||
* @version $Revision: 1.4 $
|
||||
*/
|
||||
public abstract class BaseDataSourceTest extends TestCase
|
||||
{
|
||||
public static String DATA_SOURCE_JNDI = "BaseDataSource";
|
||||
protected Connection con;
|
||||
protected BaseDataSource bds;
|
||||
|
||||
@ -60,7 +62,10 @@ public abstract class BaseDataSourceTest extends TestCase
|
||||
*/
|
||||
protected Connection getDataSourceConnection() throws SQLException
|
||||
{
|
||||
initializeDataSource();
|
||||
if(bds == null)
|
||||
{
|
||||
initializeDataSource();
|
||||
}
|
||||
return bds.getConnection();
|
||||
}
|
||||
|
||||
@ -174,6 +179,21 @@ public abstract class BaseDataSourceTest extends TestCase
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Uses the mini-JNDI implementation for testing purposes
|
||||
*/
|
||||
protected InitialContext getInitialContext()
|
||||
{
|
||||
Hashtable env = new Hashtable();
|
||||
env.put(Context.INITIAL_CONTEXT_FACTORY, "org.postgresql.test.util.MiniJndiContextFactory");
|
||||
try {
|
||||
return new InitialContext(env);
|
||||
} catch(NamingException e) {
|
||||
fail("Unable to create InitialContext: "+e.getMessage());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Eventually, we must test stuffing the DataSource in JNDI and
|
||||
* then getting it back out and make sure it's still usable. This
|
||||
@ -182,6 +202,26 @@ public abstract class BaseDataSourceTest extends TestCase
|
||||
*/
|
||||
public void testJndi()
|
||||
{
|
||||
// TODO: Put the DS in JNDI, retrieve it, and try some of this stuff again
|
||||
}
|
||||
initializeDataSource();
|
||||
BaseDataSource oldbds = bds;
|
||||
InitialContext ic = getInitialContext();
|
||||
try {
|
||||
ic.rebind(DATA_SOURCE_JNDI, bds);
|
||||
bds = (BaseDataSource)ic.lookup(DATA_SOURCE_JNDI);
|
||||
assertTrue("Got null looking up DataSource from JNDI!", bds != null);
|
||||
compareJndiDataSource(oldbds, bds);
|
||||
} catch (NamingException e) {
|
||||
fail(e.getMessage());
|
||||
}
|
||||
oldbds = bds;
|
||||
testUseConnection();
|
||||
assertTrue("Test should not have changed DataSource ("+bds+" != "+oldbds+")!", bds == oldbds);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether a DS was dereferenced from JNDI or recreated.
|
||||
*/
|
||||
protected void compareJndiDataSource(BaseDataSource oldbds, BaseDataSource bds) {
|
||||
assertTrue("DataSource was dereferenced, should have been serialized or recreated", bds != oldbds);
|
||||
}
|
||||
}
|
||||
|
||||
@ -8,7 +8,7 @@ import junit.framework.TestSuite;
|
||||
* PooledConnection implementations.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.2 $
|
||||
* @version $Revision: 1.3 $
|
||||
*/
|
||||
public class OptionalTestSuite extends TestSuite
|
||||
{
|
||||
@ -21,6 +21,7 @@ public class OptionalTestSuite extends TestSuite
|
||||
TestSuite suite = new TestSuite();
|
||||
suite.addTestSuite(SimpleDataSourceTest.class);
|
||||
suite.addTestSuite(ConnectionPoolTest.class);
|
||||
suite.addTestSuite(ConnectionPoolTest.class);
|
||||
return suite;
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,106 @@
|
||||
package org.postgresql.test.jdbc2.optional;
|
||||
|
||||
import java.sql.SQLException;
|
||||
import org.postgresql.test.TestUtil;
|
||||
import org.postgresql.jdbc2.optional.PoolingDataSource;
|
||||
import org.postgresql.jdbc2.optional.BaseDataSource;
|
||||
|
||||
/**
|
||||
* Minimal tests for pooling DataSource. Needs many more.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class PoolingDataSourceTest extends BaseDataSourceTest
|
||||
{
|
||||
private final static String DS_NAME = "JDBC 2 SE Test DataSource";
|
||||
|
||||
/**
|
||||
* Constructor required by JUnit
|
||||
*/
|
||||
public PoolingDataSourceTest(String name)
|
||||
{
|
||||
super(name);
|
||||
}
|
||||
|
||||
protected void tearDown() throws Exception
|
||||
{
|
||||
super.tearDown();
|
||||
if (bds instanceof PoolingDataSource)
|
||||
{
|
||||
((PoolingDataSource) bds).close();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates and configures a new SimpleDataSource.
|
||||
*/
|
||||
protected void initializeDataSource()
|
||||
{
|
||||
if (bds == null)
|
||||
{
|
||||
bds = new PoolingDataSource();
|
||||
String db = TestUtil.getURL();
|
||||
if (db.indexOf('/') > -1)
|
||||
{
|
||||
db = db.substring(db.lastIndexOf('/') + 1);
|
||||
}
|
||||
else if (db.indexOf(':') > -1)
|
||||
{
|
||||
db = db.substring(db.lastIndexOf(':') + 1);
|
||||
}
|
||||
bds.setDatabaseName(db);
|
||||
bds.setUser(TestUtil.getUser());
|
||||
bds.setPassword(TestUtil.getPassword());
|
||||
((PoolingDataSource) bds).setDataSourceName(DS_NAME);
|
||||
((PoolingDataSource) bds).setInitialConnections(2);
|
||||
((PoolingDataSource) bds).setMaxConnections(10);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* In this case, we *do* want it to be pooled.
|
||||
*/
|
||||
public void testNotPooledConnection()
|
||||
{
|
||||
try
|
||||
{
|
||||
con = getDataSourceConnection();
|
||||
String name = con.toString();
|
||||
con.close();
|
||||
con = getDataSourceConnection();
|
||||
String name2 = con.toString();
|
||||
con.close();
|
||||
assertTrue("Pooled DS doesn't appear to be pooling connections!", name.equals(name2));
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
fail(e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* In this case, the desired behavior is dereferencing.
|
||||
*/
|
||||
protected void compareJndiDataSource(BaseDataSource oldbds, BaseDataSource bds)
|
||||
{
|
||||
assertTrue("DataSource was serialized or recreated, should have been dereferenced", bds == oldbds);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check that 2 DS instances can't use the same name.
|
||||
*/
|
||||
public void testCantReuseName()
|
||||
{
|
||||
initializeDataSource();
|
||||
PoolingDataSource pds = new PoolingDataSource();
|
||||
try
|
||||
{
|
||||
pds.setDataSourceName(DS_NAME);
|
||||
fail("Should have denied 2nd DataSource with same name");
|
||||
}
|
||||
catch (IllegalArgumentException e)
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,67 @@
|
||||
package org.postgresql.test.jdbc3;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.SQLException;
|
||||
import javax.sql.PooledConnection;
|
||||
import org.postgresql.test.jdbc2.optional.ConnectionPoolTest;
|
||||
import org.postgresql.test.TestUtil;
|
||||
import org.postgresql.jdbc3.*;
|
||||
|
||||
/**
|
||||
* Tests JDBC3 implementation of ConnectionPoolDataSource.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class Jdbc3ConnectionPoolTest extends ConnectionPoolTest
|
||||
{
|
||||
public Jdbc3ConnectionPoolTest(String name)
|
||||
{
|
||||
super(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates and configures a Jdbc3ConnectionPool
|
||||
*/
|
||||
protected void initializeDataSource()
|
||||
{
|
||||
if (bds == null)
|
||||
{
|
||||
bds = new Jdbc3ConnectionPool();
|
||||
String db = TestUtil.getURL();
|
||||
if (db.indexOf('/') > -1)
|
||||
{
|
||||
db = db.substring(db.lastIndexOf('/') + 1);
|
||||
}
|
||||
else if (db.indexOf(':') > -1)
|
||||
{
|
||||
db = db.substring(db.lastIndexOf(':') + 1);
|
||||
}
|
||||
bds.setDatabaseName(db);
|
||||
bds.setUser(TestUtil.getUser());
|
||||
bds.setPassword(TestUtil.getPassword());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Makes sure this is a JDBC 3 implementation producing JDBC3
|
||||
* connections. Depends on toString implementation of
|
||||
* connection wrappers.
|
||||
*/
|
||||
public void testConfirmJdbc3Impl()
|
||||
{
|
||||
try
|
||||
{
|
||||
initializeDataSource();
|
||||
assertTrue("Wrong ConnectionPool impl used by test: " + bds.getClass().getName(), bds instanceof Jdbc3ConnectionPool);
|
||||
PooledConnection pc = ((Jdbc3ConnectionPool) bds).getPooledConnection();
|
||||
assertTrue("Wrong PooledConnection impl generated by JDBC3 ConnectionPoolDataSource: " + pc.getClass().getName(), pc instanceof Jdbc3PooledConnection);
|
||||
assertTrue("Wrong Connnection class used in JDBC3 ConnectionPoolDataSource's PooledConnection impl: " + pc.getConnection().toString(), pc.getConnection().toString().indexOf("Jdbc3") > -1);
|
||||
pc.close();
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
fail(e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,155 @@
|
||||
package org.postgresql.test.jdbc3;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.SQLException;
|
||||
import javax.naming.InitialContext;
|
||||
import javax.naming.NamingException;
|
||||
import org.postgresql.test.jdbc2.optional.PoolingDataSourceTest;
|
||||
import org.postgresql.test.TestUtil;
|
||||
import org.postgresql.jdbc3.Jdbc3PoolingDataSource;
|
||||
import org.postgresql.jdbc2.optional.PoolingDataSource;
|
||||
|
||||
/**
|
||||
* Minimal tests for JDBC3 pooling DataSource. Needs many more.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class Jdbc3PoolingDataSourceTest extends PoolingDataSourceTest
|
||||
{
|
||||
private final static String DS_NAME = "JDBC 3 Test DataSource";
|
||||
|
||||
/**
|
||||
* Constructor required by JUnit
|
||||
*/
|
||||
public Jdbc3PoolingDataSourceTest(String name)
|
||||
{
|
||||
super(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates and configures a new SimpleDataSource.
|
||||
*/
|
||||
protected void initializeDataSource()
|
||||
{
|
||||
if (bds == null)
|
||||
{
|
||||
bds = new Jdbc3PoolingDataSource();
|
||||
configureDataSource((Jdbc3PoolingDataSource) bds);
|
||||
}
|
||||
}
|
||||
|
||||
private void configureDataSource(PoolingDataSource source)
|
||||
{
|
||||
String db = TestUtil.getURL();
|
||||
if (db.indexOf('/') > -1)
|
||||
{
|
||||
db = db.substring(db.lastIndexOf('/') + 1);
|
||||
}
|
||||
else if (db.indexOf(':') > -1)
|
||||
{
|
||||
db = db.substring(db.lastIndexOf(':') + 1);
|
||||
}
|
||||
source.setDatabaseName(db);
|
||||
source.setUser(TestUtil.getUser());
|
||||
source.setPassword(TestUtil.getPassword());
|
||||
source.setDataSourceName(DS_NAME);
|
||||
source.setInitialConnections(2);
|
||||
source.setMaxConnections(10);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check that 2 DS instances can't use the same name.
|
||||
*/
|
||||
public void testCantReuseName()
|
||||
{
|
||||
initializeDataSource();
|
||||
Jdbc3PoolingDataSource pds = new Jdbc3PoolingDataSource();
|
||||
try
|
||||
{
|
||||
pds.setDataSourceName(DS_NAME);
|
||||
fail("Should have denied 2nd DataSource with same name");
|
||||
}
|
||||
catch (IllegalArgumentException e)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test that JDBC 2 and JDBC 3 DSs come from different buckets
|
||||
* as far as creating with the same name
|
||||
*/
|
||||
public void testDifferentImplPools()
|
||||
{
|
||||
initializeDataSource();
|
||||
PoolingDataSource pds = new PoolingDataSource();
|
||||
try
|
||||
{
|
||||
configureDataSource(pds);
|
||||
PoolingDataSource p2 = new PoolingDataSource();
|
||||
try
|
||||
{
|
||||
configureDataSource(p2);
|
||||
fail("Shouldn't be able to create 2 JDBC 2 DSs with same name");
|
||||
}
|
||||
catch (IllegalArgumentException e)
|
||||
{
|
||||
}
|
||||
Jdbc3PoolingDataSource p3 = new Jdbc3PoolingDataSource();
|
||||
try
|
||||
{
|
||||
configureDataSource(p3);
|
||||
fail("Shouldn't be able to create 2 JDBC 3 DSs with same name");
|
||||
}
|
||||
catch (IllegalArgumentException e)
|
||||
{
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
pds.close();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test that JDBC 2 and JDBC 3 DSs come from different buckets
|
||||
* as far as fetching from JNDI
|
||||
*/
|
||||
public void testDifferentImplJndi()
|
||||
{
|
||||
initializeDataSource();
|
||||
PoolingDataSource pds = new PoolingDataSource();
|
||||
try
|
||||
{
|
||||
configureDataSource(pds);
|
||||
try
|
||||
{
|
||||
Connection j3c = getDataSourceConnection();
|
||||
Connection j2c = pds.getConnection();
|
||||
j2c.close();
|
||||
j3c.close();
|
||||
InitialContext ctx = getInitialContext();
|
||||
ctx.bind("JDBC2", pds);
|
||||
ctx.bind("JDBC3", bds);
|
||||
pds = (PoolingDataSource) ctx.lookup("JDBC2");
|
||||
bds = (Jdbc3PoolingDataSource) ctx.lookup("JDBC3");
|
||||
j2c = pds.getConnection();
|
||||
j3c = bds.getConnection();
|
||||
j2c.close();
|
||||
j3c.close();
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
fail(e.getMessage());
|
||||
}
|
||||
catch (NamingException e)
|
||||
{
|
||||
fail(e.getMessage());
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
pds.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,60 @@
|
||||
package org.postgresql.test.jdbc3;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.SQLException;
|
||||
import org.postgresql.test.jdbc2.optional.SimpleDataSourceTest;
|
||||
import org.postgresql.test.TestUtil;
|
||||
import org.postgresql.jdbc3.*;
|
||||
|
||||
/**
|
||||
* Tests JDBC3 non-pooling DataSource.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class Jdbc3SimpleDataSourceTest extends SimpleDataSourceTest {
|
||||
/**
|
||||
* Constructor required by JUnit
|
||||
*/
|
||||
public Jdbc3SimpleDataSourceTest(String name)
|
||||
{
|
||||
super(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates and configures a new SimpleDataSource.
|
||||
*/
|
||||
protected void initializeDataSource()
|
||||
{
|
||||
if (bds == null)
|
||||
{
|
||||
bds = new Jdbc3SimpleDataSource();
|
||||
String db = TestUtil.getURL();
|
||||
if (db.indexOf('/') > -1)
|
||||
{
|
||||
db = db.substring(db.lastIndexOf('/') + 1);
|
||||
}
|
||||
else if (db.indexOf(':') > -1)
|
||||
{
|
||||
db = db.substring(db.lastIndexOf(':') + 1);
|
||||
}
|
||||
bds.setDatabaseName(db);
|
||||
bds.setUser(TestUtil.getUser());
|
||||
bds.setPassword(TestUtil.getPassword());
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Makes sure this is a JDBC 3 implementation producing JDBC3
|
||||
* connections.
|
||||
*/
|
||||
public void testConfirmJdbc3Impl()
|
||||
{
|
||||
try {
|
||||
Connection con = getDataSourceConnection();
|
||||
assertTrue("Wrong SimpleDataSource impl used by test: "+bds.getClass().getName(), bds instanceof Jdbc3SimpleDataSource);
|
||||
assertTrue("Wrong Connnection class generated by JDBC3 DataSource: "+con.getClass().getName(), con instanceof Jdbc3Connection);
|
||||
} catch (SQLException e) {
|
||||
fail(e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,10 +1,6 @@
|
||||
package org.postgresql.test.jdbc3;
|
||||
|
||||
import junit.framework.TestSuite;
|
||||
import junit.framework.TestCase;
|
||||
import junit.framework.Test;
|
||||
|
||||
import java.sql.*;
|
||||
|
||||
/*
|
||||
* Executes all known tests for JDBC3
|
||||
@ -17,7 +13,11 @@ public class Jdbc3TestSuite extends TestSuite
|
||||
*/
|
||||
public static TestSuite suite()
|
||||
{
|
||||
//Currently there are no specific jdbc3 tests so just run the jdbc2 tests
|
||||
return org.postgresql.test.jdbc2.Jdbc2TestSuite.suite();
|
||||
TestSuite suite = new TestSuite();
|
||||
suite.addTest(org.postgresql.test.jdbc2.Jdbc2TestSuite.suite());
|
||||
suite.addTestSuite(Jdbc3SimpleDataSourceTest.class);
|
||||
suite.addTestSuite(Jdbc3ConnectionPoolTest.class);
|
||||
suite.addTestSuite(Jdbc3PoolingDataSourceTest.class);
|
||||
return suite;
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,228 @@
|
||||
package org.postgresql.test.util;
|
||||
|
||||
import java.util.*;
|
||||
import java.rmi.MarshalledObject;
|
||||
import java.io.Serializable;
|
||||
import javax.naming.*;
|
||||
import javax.naming.spi.ObjectFactory;
|
||||
|
||||
/**
|
||||
* The Context for a trivial JNDI implementation. This is not meant to
|
||||
* be very useful, beyond testing JNDI features of the connection
|
||||
* pools. It is not a complete JNDI implementations.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class MiniJndiContext implements Context
|
||||
{
|
||||
private Map map = new HashMap();
|
||||
|
||||
public MiniJndiContext()
|
||||
{
|
||||
}
|
||||
|
||||
public Object lookup(Name name) throws NamingException
|
||||
{
|
||||
return lookup(name.get(0));
|
||||
}
|
||||
|
||||
public Object lookup(String name) throws NamingException
|
||||
{
|
||||
Object o = map.get(name);
|
||||
if (o == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if (o instanceof Reference)
|
||||
{
|
||||
Reference ref = (Reference) o;
|
||||
try
|
||||
{
|
||||
Class factoryClass = Class.forName(ref.getFactoryClassName());
|
||||
ObjectFactory fac = (ObjectFactory) factoryClass.newInstance();
|
||||
Object result = fac.getObjectInstance(ref, null, this, null);
|
||||
return result;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new NamingException("Unable to dereference to object: " + e);
|
||||
}
|
||||
}
|
||||
else if (o instanceof MarshalledObject)
|
||||
{
|
||||
try
|
||||
{
|
||||
Object result = ((MarshalledObject) o).get();
|
||||
return result;
|
||||
}
|
||||
catch (java.io.IOException e)
|
||||
{
|
||||
throw new NamingException("Unable to deserialize object: " + e);
|
||||
}
|
||||
catch (ClassNotFoundException e)
|
||||
{
|
||||
throw new NamingException("Unable to deserialize object: " + e);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new NamingException("JNDI Object is neither Referenceable nor Serializable");
|
||||
}
|
||||
}
|
||||
|
||||
public void bind(Name name, Object obj) throws NamingException
|
||||
{
|
||||
rebind(name.get(0), obj);
|
||||
}
|
||||
|
||||
public void bind(String name, Object obj) throws NamingException
|
||||
{
|
||||
rebind(name, obj);
|
||||
}
|
||||
|
||||
public void rebind(Name name, Object obj) throws NamingException
|
||||
{
|
||||
rebind(name.get(0), obj);
|
||||
}
|
||||
|
||||
public void rebind(String name, Object obj) throws NamingException
|
||||
{
|
||||
if (obj instanceof Referenceable)
|
||||
{
|
||||
Reference ref = ((Referenceable) obj).getReference();
|
||||
map.put(name, ref);
|
||||
}
|
||||
else if (obj instanceof Serializable)
|
||||
{
|
||||
try
|
||||
{
|
||||
MarshalledObject mo = new MarshalledObject(obj);
|
||||
map.put(name, mo);
|
||||
}
|
||||
catch (java.io.IOException e)
|
||||
{
|
||||
throw new NamingException("Unable to serialize object to JNDI: " + e);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new NamingException("Object to store in JNDI is neither Referenceable nor Serializable");
|
||||
}
|
||||
}
|
||||
|
||||
public void unbind(Name name) throws NamingException
|
||||
{
|
||||
unbind(name.get(0));
|
||||
}
|
||||
|
||||
public void unbind(String name) throws NamingException
|
||||
{
|
||||
map.remove(name);
|
||||
}
|
||||
|
||||
public void rename(Name oldName, Name newName) throws NamingException
|
||||
{
|
||||
rename(oldName.get(0), newName.get(0));
|
||||
}
|
||||
|
||||
public void rename(String oldName, String newName) throws NamingException
|
||||
{
|
||||
map.put(newName, map.remove(oldName));
|
||||
}
|
||||
|
||||
public NamingEnumeration list(Name name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public NamingEnumeration list(String name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public NamingEnumeration listBindings(Name name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public NamingEnumeration listBindings(String name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public void destroySubcontext(Name name) throws NamingException
|
||||
{
|
||||
}
|
||||
|
||||
public void destroySubcontext(String name) throws NamingException
|
||||
{
|
||||
}
|
||||
|
||||
public Context createSubcontext(Name name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public Context createSubcontext(String name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public Object lookupLink(Name name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public Object lookupLink(String name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public NameParser getNameParser(Name name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public NameParser getNameParser(String name) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public Name composeName(Name name, Name prefix) throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public String composeName(String name, String prefix)
|
||||
throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public Object addToEnvironment(String propName, Object propVal)
|
||||
throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public Object removeFromEnvironment(String propName)
|
||||
throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public Hashtable getEnvironment() throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public void close() throws NamingException
|
||||
{
|
||||
}
|
||||
|
||||
public String getNameInNamespace() throws NamingException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,22 @@
|
||||
package org.postgresql.test.util;
|
||||
|
||||
import java.util.*;
|
||||
import javax.naming.*;
|
||||
import javax.naming.spi.InitialContextFactory;
|
||||
|
||||
/**
|
||||
* The ICF for a trivial JNDI implementation. This is not meant to
|
||||
* be very useful, beyond testing JNDI features of the connection
|
||||
* pools.
|
||||
*
|
||||
* @author Aaron Mulder (ammulder@chariotsolutions.com)
|
||||
* @version $Revision: 1.1 $
|
||||
*/
|
||||
public class MiniJndiContextFactory implements InitialContextFactory
|
||||
{
|
||||
public Context getInitialContext(Hashtable environment)
|
||||
throws NamingException
|
||||
{
|
||||
return new MiniJndiContext();
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user