org.eclipse.persistence.sessions.factories.SessionManager Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.sessions.factories;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.eclipse.persistence.internal.sessions.factories.model.SessionConfigs;
import org.eclipse.persistence.logging.*;
import org.eclipse.persistence.sessions.*;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedGetClassLoaderForClass;
import org.eclipse.persistence.internal.sessions.AbstractSession;
/**
*
* Purpose: Global session location.
*
* Description: This allows for a global session local which can
* be accessed globally from other classes. This is needed for EJB data stores
* as they must have a globally accessible place to access the session.
* This can be by EJB session beans, BMP beans and CMP beans as well as Servlets and
* other three-tier services.
*
* Responsibilities:
*
* - Store a global session.
*
- Allow the storage of alternative sessions as well.
*
*
* @author James Sutherland
* @since TOPLink/Java 3.0
*/
public class SessionManager {
/** Allow for usage of schema validation to be configurable. */
protected static boolean shouldUseSchemaValidation = true;
protected static SessionManager manager = initializeManager();
protected AbstractSession defaultSession;
protected ConcurrentMap sessions = null;
protected static boolean shouldPerformDTDValidation;
/**
* PUBLIC:
* Return if schema validation will be used when parsing the 10g (10.1.3) sessions XML.
*/
public static boolean shouldUseSchemaValidation() {
return shouldUseSchemaValidation;
}
/**
* PUBLIC:
* Set if schema validation will be used when parsing the 10g (10.1.3) sessions XML.
* By default schema validation is on, but can be turned off if validation problems occur,
* or to improve parsing performance.
*/
public static void setShouldUseSchemaValidation(boolean value) {
shouldUseSchemaValidation = value;
}
/**
* PUBLIC:
* The default constructor to create a new session manager.
*/
public SessionManager() {
sessions = new ConcurrentHashMap(5);
}
/**
* INTERNAL:
* add an named session to the hashtable.
* session must have a name prior to setting into session Manager
*/
public void addSession(Session session) {
getSessions().put(session.getName(), session);
}
/**
* ADVANCED:
* add an named session to the hashtable.
*/
public void addSession(String sessionName, Session session) {
session.setName(sessionName);
getSessions().put(sessionName, session);
}
/**
* PUBLIC:
* Return the default session.
* The session configuration is stored in a sessions.xml file in a
* directory on your classpath. Other sessions are supported through the
* getSession by name API.
*/
public Session getDefaultSession() {
if (defaultSession == null) {
defaultSession = getSession("default");
}
return defaultSession;
}
/**
* INTERNAL:
* Destroy the session defined by sessionName on this manager.
*/
public void destroySession(String sessionName) {
DatabaseSession session = (DatabaseSession)getSessions().get(sessionName);
if (session != null) {
destroy(session);
} else {
logAndThrowException(SessionLog.WARNING, ValidationException.noSessionRegisteredForName(sessionName));
}
}
private void destroy(DatabaseSession session) {
try {
if (session.isConnected()) {
session.logout();
}
} catch (Throwable ignore) {
// EL Bug 321843 - Must handle errors from logout.
AbstractSessionLog.getLog().logThrowable(SessionLog.WARNING, AbstractSessionLog.CONNECTION, ignore);
}
sessions.remove(session.getName());
session = null;
}
/**
* INTERNAL:
* Destroy all sessions held onto by this manager.
*/
public void destroyAllSessions() {
Iterator toRemoveSessions = new ArrayList(getSessions().values()).iterator();
while (toRemoveSessions.hasNext()) {
destroy((DatabaseSession)toRemoveSessions.next());
}
}
/**
* INTERNAL:
*/
public synchronized SessionConfigs getInternalMWConfigObjects(String resourceName, ClassLoader objectClassLoader) {
return getInternalMWConfigObjects(resourceName, objectClassLoader, true);
}
/**
* INTERNAL:
*/
public synchronized SessionConfigs getInternalMWConfigObjects(String resourceName, ClassLoader objectClassLoader, boolean validate) {
return new XMLSessionConfigLoader(resourceName).loadConfigsForMappingWorkbench(objectClassLoader, validate);
}
/**
* PUBLIC:
* Return the singleton session manager.
* This allow global access to a set of named sessions.
*/
public static SessionManager getManager() {
if (manager == null) {
initializeManager();
}
return manager;
}
/**
* INTERNAL:
* Initialize the singleton session manager.
*/
protected static SessionManager initializeManager() {
return new SessionManager();
}
/**
* PUBLIC:
* Return the session by name.
*/
public org.eclipse.persistence.internal.sessions.AbstractSession getSession(String sessionName) {
XMLSessionConfigLoader loader = new XMLSessionConfigLoader();
loader.setSessionName(sessionName);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name.
* Log the session in only if specified.
*/
public org.eclipse.persistence.internal.sessions.AbstractSession getSession(String sessionName, boolean shouldLoginSession) {
XMLSessionConfigLoader loader = new XMLSessionConfigLoader();
loader.setSessionName(sessionName);
loader.setShouldLogin(shouldLoginSession);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name.
* Log the session in only if specified.
* Refresh the session only if specified.
*/
public org.eclipse.persistence.internal.sessions.AbstractSession getSession(String sessionName, boolean shouldLoginSession, boolean shouldRefreshSession) {
XMLSessionConfigLoader loader = new XMLSessionConfigLoader();
loader.setSessionName(sessionName);
loader.setShouldLogin(shouldLoginSession);
loader.setShouldRefresh(shouldRefreshSession);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name, using the classloader of the Object specified.
* This method is used in older versions of BMP support
* This method will cause the class loader of the provided object to be
* compared with the classloader used to load the original session of this
* name, with this classloader. If they are not the same then the session
* will be refreshed.
*/
public org.eclipse.persistence.internal.sessions.AbstractSession getSession(String sessionName, Object objectBean) {
XMLSessionConfigLoader loader = new XMLSessionConfigLoader();
loader.setSessionName(sessionName);
ClassLoader classLoader = null;
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try{
classLoader = (ClassLoader) AccessController.doPrivileged(new PrivilegedGetClassLoaderForClass(objectBean.getClass()));
}catch (PrivilegedActionException ex){
throw (RuntimeException) ex.getCause();
}
}else{
classLoader = PrivilegedAccessHelper.getClassLoaderForClass(objectBean.getClass());
}
loader.setClassLoader(classLoader);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name, in the file specified.
* Login the session.
*/
public org.eclipse.persistence.internal.sessions.AbstractSession getSession(String sessionName, String filename) {
XMLSessionConfigLoader loader = new XMLSessionConfigLoader();
loader.setSessionName(sessionName);
loader.setResourceName(filename);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name, in the file specified, using the class loader to find the resource.
* This method will cause the class loader to be compared with the classloader
* used to load the original session of this name.
* If they are not the same then the session will be refreshed.
*/
public AbstractSession getSession(String sessionName, String filename, ClassLoader classLoader) {
XMLSessionConfigLoader loader = new XMLSessionConfigLoader();
loader.setSessionName(sessionName);
loader.setResourceName(filename);
loader.setClassLoader(classLoader);
loader.setShouldCheckClassLoader(true);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name.
* Provide the class loader for loading the project, the configuration file
* and the deployed classes.
* E.g. SessionManager.getManager().getSession("mySession", MySessionBean.getClassLoader());
* This method will cause the class loader to be compared with the classloader
* used to load the original session of this name.
* If they are not the same then the session will be refreshed.
*/
public AbstractSession getSession(String sessionName, ClassLoader objectClassLoader) {
XMLSessionConfigLoader loader = new XMLSessionConfigLoader();
loader.setSessionName(sessionName);
loader.setClassLoader(objectClassLoader);
loader.setShouldCheckClassLoader(true);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name, loading the configuration from the file
* specified in the XMLSessionConfigLoader. Provide the class loader for
* loading the project, the configuration file and the deployed classes.
* This method will cause the class loader to be compared with the classloader
* used to load the original session of this name.
* If they are not the same then the session will be refreshed.
*/
public AbstractSession getSession(XMLSessionConfigLoader loader, String sessionName, ClassLoader objectClassLoader) {
if (loader == null){
loader = new XMLSessionConfigLoader();
}
loader.setSessionName(sessionName);
loader.setClassLoader(objectClassLoader);
loader.setShouldCheckClassLoader(true);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name, loading the configuration from the file
* specified in the loader. Provide the class loader for loading the
* project, the configuration file and the deployed classes. Pass in true for
* shouldLoginSession if the session returned should be logged in before
* returned otherwise false. Pass in true for shouldRefreshSession if the
* XMLSessionConfigLoader should reparse the configuration file for new
* sessions. False, will cause the XMLSessionConfigLoader not to parse the
* file again.
*/
public AbstractSession getSession(XMLSessionConfigLoader loader, String sessionName, ClassLoader objectClassLoader, boolean shouldLoginSession, boolean shouldRefreshSession) {
if (loader == null){
loader = new XMLSessionConfigLoader();
}
loader.setSessionName(sessionName);
loader.setClassLoader(objectClassLoader);
loader.setShouldLogin(shouldLoginSession);
loader.setShouldRefresh(shouldRefreshSession);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name, loading the configuration from the file
* specified in the loader. Provide the class loader for loading the
* project, the configuration file and the deployed classes. Pass in true for
* shouldLoginSession if the session returned should be logged in before
* returned otherwise false. Pass in true for shouldRefreshSession if the
* XMLSessionConfigLoader should reparse the configuration file for new
* sessions. False, will cause the XMLSessionConfigLoader not to parse the
* file again.
* Pass true for shouldCheckClassLoader will cause the class loader to be compared with the classloader
* used to load the original session of this name.
* If they are not the same then the session will be refreshed, this can be used for re-deployment.
*/
public AbstractSession getSession(XMLSessionConfigLoader loader, String sessionName, ClassLoader objectClassLoader, boolean shouldLoginSession, boolean shouldRefreshSession, boolean shouldCheckClassLoader) {
if (loader == null){
loader = new XMLSessionConfigLoader();
}
loader.setSessionName(sessionName);
loader.setClassLoader(objectClassLoader);
loader.setShouldLogin(shouldLoginSession);
loader.setShouldRefresh(shouldRefreshSession);
loader.setShouldCheckClassLoader(shouldCheckClassLoader);
return getSession(loader);
}
/**
* PUBLIC:
* Return the session by name, loading the configuration from the file
* specified in the loader, using the loading options provided on the loader.
*/
public AbstractSession getSession(XMLSessionConfigLoader loader) {
AbstractSession session = (AbstractSession)getSessions().get(loader.getSessionName());
boolean shouldRefreshSession = loader.shouldRefresh();
if (loader.shouldCheckClassLoader() && (session != null) && !session.getDatasourcePlatform().getConversionManager().getLoader().equals(loader.getClassLoader())) {
//bug 3766808 if a different classloader is being used then a reload of the session should
//be completed otherwise failures may occur
shouldRefreshSession = true;
}
if ((session == null) || shouldRefreshSession) {
// PERF: Avoid synchronization for normal get.
synchronized (this) {
// Must re-assert checks inside synchronization.
session = (AbstractSession)getSessions().get(loader.getSessionName());
if (loader.shouldCheckClassLoader() && (session != null) && !session.getDatasourcePlatform().getConversionManager().getLoader().equals(loader.getClassLoader())) {
//bug 3766808 if a different classloader is being used then a reload of the session should
//be completed otherwise failures may occur
shouldRefreshSession = true;
}
if ((session == null) || shouldRefreshSession) {
if (session != null) {
if (session.isDatabaseSession() && session.isConnected()) {
// Must handles errors from logout as session maybe hosed.
try {
((DatabaseSession)session).logout();
} catch (Throwable ignore) {
AbstractSessionLog.getLog().logThrowable(SessionLog.WARNING, AbstractSessionLog.CONNECTION, ignore);
}
}
getSessions().remove(loader.getSessionName());
}
if (loader.load(this, loader.getClassLoader())) {
session = (AbstractSession)getSessions().get(loader.getSessionName());
}
}
}
}
// Connect the session if specified.
if (session == null) {
logAndThrowException(SessionLog.WARNING, ValidationException.noSessionFound(loader.getSessionName(), loader.getResourcePath()));
} else if (loader.shouldLogin() && !session.isConnected()) {
// PERF: Avoid synchronization for normal get.
synchronized (this) {
// Must re-assert checks inside synchronization.
if (loader.shouldLogin() && !session.isConnected()) {
((DatabaseSession)session).login();
}
}
}
return session;
}
/**
* INTERNAL:
* Log exceptions to the default log then throw them.
*/
private void logAndThrowException(int level, RuntimeException exception) throws RuntimeException {
AbstractSessionLog.getLog().logThrowable(level, AbstractSessionLog.CONNECTION, exception);
throw exception;
}
/**
* INTERNAL:
* Set a hashtable of all sessions
*/
public void setSessions(ConcurrentMap sessions) {
this.sessions = sessions;
}
/**
* INTERNAL:
* Return a hashtable on all sessions.
*/
public ConcurrentMap getSessions() {
return sessions;
}
/**
* PUBLIC:
* Set the default session.
* If not set the session configuration is stored in a sessions.xml
* file in a TopLink directory on your classpath.
* Other sessions are supported through the getSession by name API.
*/
public void setDefaultSession(Session defaultSession) {
this.defaultSession = (org.eclipse.persistence.internal.sessions.AbstractSession)defaultSession;
addSession("default", defaultSession);
}
/**
* INTERNAL:
* Set the singleton session manager.
* This allows global access to a set of named sessions.
*/
public static void setManager(SessionManager theManager) {
manager = theManager;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy