/*
* Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
*
* This file is part of Resin(R) Open Source
*
* Each copy or derived work must preserve the copyright notice and this
* notice unmodified.
*
* Resin Open Source is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Resin Open Source 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, or any warranty
* of NON-INFRINGEMENT. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with Resin Open Source; if not, write to the
* Free SoftwareFoundation, Inc.
* 59 Temple Place, Suite 330
* Boston, MA 02111-1307 USA
*
* @author Scott Ferguson
*/
package com.caucho.ejb.session;
import java.util.HashMap;
import java.util.logging.Logger;
import javax.ejb.EJBException;
import javax.ejb.EJBHome;
import javax.ejb.EJBLocalHome;
import javax.ejb.EJBLocalObject;
import javax.ejb.EJBObject;
import javax.ejb.SessionContext;
import javax.xml.rpc.handler.MessageContext;
import com.caucho.config.async.AsyncItem;
import com.caucho.config.gen.CandiEnhancedBean;
import com.caucho.config.inject.CreationalContextImpl;
import com.caucho.config.inject.InjectManager;
import com.caucho.ejb.server.AbstractContext;
import com.caucho.util.L10N;
/**
* Abstract base class for an session context
*/
abstract public class AbstractSessionContext<X,T> extends AbstractContext<X>
implements SessionContext
{
private static final Logger log
= Logger.getLogger(AbstractSessionContext.class.getName());
private static final L10N L = new L10N(AbstractSessionContext.class);
private transient AbstractSessionManager<X> _manager;
private transient InjectManager _injectManager;
private transient ClassLoader _classLoader;
private Class<T> _api;
private SessionProxyFactory<T> _proxyFactory;
protected AbstractSessionContext(AbstractSessionManager<X> manager,
Class<T> api)
{
assert(manager != null);
_classLoader = Thread.currentThread().getContextClassLoader();
_manager = manager;
_api = api;
_injectManager = InjectManager.create();
}
@Override
public AbstractSessionManager<X> getServer()
{
return _manager;
}
public InjectManager getInjectManager()
{
return _injectManager;
}
public InjectManager getModuleInjectManager()
{
return _manager.getModuleInjectManager();
}
/*
* Returns the API for the context
*/
public Class<T> getApi()
{
return _api;
}
@Override
public Class<?> getInvokedBusinessInterface()
{
return getApi();
}
void bind()
{
if (_proxyFactory == null)
_proxyFactory = _manager.createProxyFactory(this);
}
public T createProxy(CreationalContextImpl<T> env)
{
if (_proxyFactory == null)
bind();
T proxy = _proxyFactory.__caucho_createProxy(env);
return proxy;
}
protected SessionProxyFactory<T> getProxyFactory()
{
return _proxyFactory;
}
public void destroyProxy(T instance, CreationalContextImpl<T> env)
{
if (instance instanceof CandiEnhancedBean) {
CandiEnhancedBean candiInstance = (CandiEnhancedBean) instance;
candiInstance.__caucho_destroy(env);
}
}
public X newInstance(CreationalContextImpl<X> env)
{
Thread thread = Thread.currentThread();
ClassLoader oldLoader = thread.getContextClassLoader();
try {
thread.setContextClassLoader(_classLoader);
X instance = _manager.newInstance(env);
return instance;
} finally {
thread.setContextClassLoader(oldLoader);
}
}
@Override
public void destroy()
throws Exception
{
if (_proxyFactory != null)
_proxyFactory.__caucho_destroy();
super.destroy();
}
/**
* Returns the EJBHome stub for the container.
*/
@Override
public EJBHome getEJBHome()
{
throw new EJBException(L.l("EJBHome does not exist for this class"));
}
/**
* Returns the EJBLocalHome stub for the container.
*/
@Override
public EJBLocalHome getEJBLocalHome()
{
throw new EJBException(L.l("EJBLocalHome does not exist for this class"));
}
@Override
public MessageContext getMessageContext()
{
throw new IllegalStateException(getClass().getName());
}
@Override
public boolean wasCancelCalled()
{
return AsyncItem.isThreadCancelled();
}
@Override
public <Z> Z getBusinessObject(Class<Z> businessInterface)
throws IllegalStateException
{
if (businessInterface== null) {
throw new IllegalStateException(L.l("null is not a valid local interface or no-interface view for {0}",
getServer().getEjbClass().getName()));
}
AbstractSessionContext<?,Z> context =
getServer().getSessionContext(businessInterface);
if (context == null) {
throw new IllegalStateException(L.l("{0} is not a valid local interface or no-interface view for {1}",
businessInterface.getName(),
getServer().getEjbClass().getName()));
}
// return context.createProxy(null);
return context.getLocal();
}
protected T getLocal()
{
return createProxy(null);
}
@Override
public EJBLocalObject getEJBLocalObject() throws IllegalStateException
{
throw new UnsupportedOperationException(getClass().getName());
}
@Override
public EJBObject getEJBObject() throws IllegalStateException
{
throw new UnsupportedOperationException(getClass().getName());
}
@Override
public String toString()
{
return getClass().getSimpleName() + "[" + _api.getName() + "]";
}
static interface CancelCalled {
boolean wasCancelCalled();
}
}