package org.apache.ojb.broker.metadata;
/* Copyright 2002-2004 The Apache Software Foundation
*
* 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.
*/
import org.apache.commons.lang.SerializationUtils;
import org.apache.commons.lang.SystemUtils;
import org.apache.ojb.broker.PBKey;
import org.apache.ojb.broker.util.logging.Logger;
import org.apache.ojb.broker.util.logging.LoggerFactory;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import javax.sql.DataSource;
public class ConnectionRepository implements Serializable, XmlCapable
{
private static final long serialVersionUID = -5581126412817848887L;
private static Logger log = LoggerFactory.getLogger(ConnectionRepository.class);
private HashMap jcdMap;
private Hashtable jcdAliasToPBKeyMap;
private JdbcMetadataUtils utils;
public ConnectionRepository()
{
jcdMap = new HashMap();
jcdAliasToPBKeyMap = new Hashtable();
utils = new JdbcMetadataUtils();
}
/**
* Returns the matching {@link JdbcConnectionDescriptor}
* or <code>null</code> if no descriptor could be found. The user name
* and pass word will be set to match the supplied </code>PBKey</code>
* object. If the original user name and pass word are desired, the PBKey
* should be obtained with {@link #getStandardPBKeyForJcdAlias(String)}.
*/
public JdbcConnectionDescriptor getDescriptor(PBKey pbKey)
{
JdbcConnectionDescriptor result = (JdbcConnectionDescriptor) jcdMap.get(pbKey);
if (result == null)
{
result = deepCopyOfFirstFound(pbKey.getAlias());
if (result != null)
{
result.setUserName(pbKey.getUser());
result.setPassWord(pbKey.getPassword());
// this build connection descriptor could not be the default connection
result.setDefaultConnection(false);
log.info("Automatic create of new jdbc-connection-descriptor for PBKey " + pbKey);
addDescriptor(result);
}
else
{
log.info("Could not find " + JdbcConnectionDescriptor.class.getName() + " for PBKey " + pbKey);
}
}
return result;
}
/**
* Returns a deep copy of the first found connection descriptor
* with the given <code>jcdAlias</code> name or <code>null</code>
* if none found.
*/
private JdbcConnectionDescriptor deepCopyOfFirstFound(String jcdAlias)
{
Iterator it = jcdMap.values().iterator();
JdbcConnectionDescriptor jcd;
while (it.hasNext())
{
jcd = (JdbcConnectionDescriptor) it.next();
if (jcdAlias.equals(jcd.getJcdAlias()))
{
return (JdbcConnectionDescriptor) SerializationUtils.clone(jcd);
}
}
return null;
}
/**
* Return the matching {@link org.apache.ojb.broker.PBKey} for
* the given jcdAlias name, or <code>null</code> if no match
* was found.
*/
public PBKey getStandardPBKeyForJcdAlias(String jcdAlias)
{
return (PBKey) jcdAliasToPBKeyMap.get(jcdAlias);
}
/**
* Add a new {@link JdbcConnectionDescriptor}.
*/
public void addDescriptor(JdbcConnectionDescriptor jcd)
{
synchronized (jcdMap)
{
if (jcdMap.containsKey(jcd.getPBKey()))
{
throw new MetadataException("Found duplicate connection descriptor using PBKey " +
jcd.getPBKey() + ", remove the old descriptor first, before add the new one. " + jcd);
}
jcdMap.put(jcd.getPBKey(), jcd);
// only if the jcdAlias was not found, put the new PBKey,
// because we don't want to replace the original PBKey with
// automatic generated descriptors PBKey's - see method getDescriptor(PBKey key)
if (!jcdAliasToPBKeyMap.containsKey(jcd.getJcdAlias()))
{
jcdAliasToPBKeyMap.put(jcd.getJcdAlias(), jcd.getPBKey());
}
if (log.isDebugEnabled()) log.debug("New descriptor was added: " + jcd);
}
}
/**
* Creates and adds a new connection descriptor for the given JDBC connection url.
* This method tries to guess the platform to be used, but it should be checked
* afterwards nonetheless using the {@link JdbcConnectionDescriptor#getDbms()} method.
* For properties that are not part of the url, the following standard values are
* explicitly set:
* <ul>
* <li>jdbc level = 2.0</li>
* </ul>
*
* @param jcdAlias The connection alias for the created connection; if 'default' is used,
* then the new descriptor will become the default connection descriptor
* @param jdbcDriver The fully qualified jdbc driver name
* @param jdbcConnectionUrl The connection url of the form '[protocol]:[sub protocol]:{database-specific path]'
* where protocol is usually 'jdbc'
* @param username The user name (can be <code>null</code>)
* @param password The password (can be <code>null</code>)
* @return The created connection descriptor
* @see JdbcConnectionDescriptor#getDbms()
*/
public JdbcConnectionDescriptor addDescriptor(String jcdAlias, String jdbcDriver, String jdbcConnectionUrl, String username, String password)
{
JdbcConnectionDescriptor jcd = new JdbcConnectionDescriptor();
HashMap props = utils.parseConnectionUrl(jdbcConnectionUrl);
jcd.setJcdAlias(jcdAlias);
jcd.setProtocol((String)props.get(JdbcMetadataUtils.PROPERTY_PROTOCOL));
jcd.setSubProtocol((String)props.get(JdbcMetadataUtils.PROPERTY_SUBPROTOCOL));
jcd.setDbAlias((String)props.get(JdbcMetadataUtils.PROPERTY_DBALIAS));
String platform = utils.findPlatformFor(jcd.getSubProtocol(), jdbcDriver);
jcd.setDbms(platform);
jcd.setJdbcLevel(2.0);
jcd.setDriver(jdbcDriver);
if (username != null)
{
jcd.setUserName(username);
jcd.setPassWord(password);
}
if ("default".equals(jcdAlias))
{
jcd.setDefaultConnection(true);
MetadataManager.getInstance().setDefaultPBKey(new PBKey(jcd.getJcdAlias(), jcd.getUserName(), jcd.getPassWord()));
}
addDescriptor(jcd);
return jcd;
}
/**
* Creates and adds a new connection descriptor for the given JDBC data source.
* This method tries to guess the platform to be used, but it should be checked
* afterwards nonetheless using the {@link JdbcConnectionDescriptor#getDbms()} method.
* Note that the descriptor won't have a value for the driver because it is not possible
* to retrieve the driver classname from the data source.
*
* @param jcdAlias The connection alias for the created connection; if 'default' is used,
* then the new descriptor will become the default connection descriptor
* @param dataSource The data source
* @param username The user name (can be <code>null</code>)
* @param password The password (can be <code>null</code>)
* @return The created connection descriptor
* @see JdbcConnectionDescriptor#getDbms()
*/
public JdbcConnectionDescriptor addDescriptor(String jcdAlias, DataSource dataSource, String username, String password)
{
JdbcConnectionDescriptor jcd = new JdbcConnectionDescriptor();
jcd.setJcdAlias(jcdAlias);
jcd.setDataSource(dataSource);
if (username != null)
{
jcd.setUserName(username);
jcd.setPassWord(password);
}
utils.fillJCDFromDataSource(jcd, dataSource, username, password);
if ("default".equals(jcdAlias))
{
jcd.setDefaultConnection(true);
MetadataManager.getInstance().setDefaultPBKey(new PBKey(jcd.getJcdAlias(), jcd.getUserName(), jcd.getPassWord()));
}
addDescriptor(jcd);
return jcd;
}
/**
* Remove a descriptor.
* @param validKey This could be the {@link JdbcConnectionDescriptor}
* itself, or the associated {@link JdbcConnectionDescriptor#getPBKey PBKey}.
*/
public void removeDescriptor(Object validKey)
{
PBKey pbKey;
if (validKey instanceof PBKey)
{
pbKey = (PBKey) validKey;
}
else if (validKey instanceof JdbcConnectionDescriptor)
{
pbKey = ((JdbcConnectionDescriptor) validKey).getPBKey();
}
else
{
throw new MetadataException("Could not remove descriptor, given object was no vaild key: " +
validKey);
}
Object removed = null;
synchronized (jcdMap)
{
removed = jcdMap.remove(pbKey);
jcdAliasToPBKeyMap.remove(pbKey.getAlias());
}
log.info("Remove descriptor: " + removed);
}
/**
* Return a deep copy of all managed {@link JdbcConnectionDescriptor}.
*/
public List getAllDescriptor()
{
return (List) SerializationUtils.clone(new ArrayList(jcdMap.values()));
}
public String toXML()
{
String eol = SystemUtils.LINE_SEPARATOR;
// use copy to avoid sync problems
HashMap map = (HashMap) jcdMap.clone();
StringBuffer buf = new StringBuffer();
Iterator it = map.values().iterator();
while (it.hasNext())
{
JdbcConnectionDescriptor jcd = (JdbcConnectionDescriptor) it.next();
buf.append(jcd.toXML());
buf.append(eol);
}
return buf.toString();
}
}