/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
package org.apache.openejb.cdi;
import org.apache.openejb.BeanContext;
import org.apache.openejb.BeanType;
import org.apache.openejb.OpenEJBRuntimeException;
import org.apache.openejb.assembler.classic.ProxyInterfaceResolver;
import org.apache.webbeans.config.OWBLogConst;
import org.apache.webbeans.config.WebBeansContext;
import org.apache.webbeans.decorator.WebBeansDecorator;
import org.apache.webbeans.ejb.common.component.BaseEjbBean;
import org.apache.webbeans.exception.WebBeansConfigurationException;
import org.apache.webbeans.intercept.InterceptorData;
import org.apache.webbeans.intercept.webbeans.WebBeansInterceptor;
import org.apache.webbeans.logger.WebBeansLoggerFacade;
import javax.ejb.NoSuchEJBException;
import javax.ejb.Remove;
import javax.enterprise.context.Dependent;
import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.inject.Disposes;
import javax.enterprise.inject.Typed;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.Decorator;
import javax.enterprise.inject.spi.InjectionPoint;
import javax.enterprise.inject.spi.SessionBeanType;
import javax.persistence.EntityManager;
import java.io.Serializable;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.UndeclaredThrowableException;
import java.rmi.NoSuchObjectException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
public class CdiEjbBean<T> extends BaseEjbBean<T> {
private final Map<Integer, Object> dependentSFSBToBeRemoved = new ConcurrentHashMap<Integer, Object>();
private final BeanContext beanContext;
public CdiEjbBean(BeanContext beanContext, WebBeansContext webBeansContext) {
this(beanContext, webBeansContext, beanContext.getManagedClass());
}
public CdiEjbBean(BeanContext beanContext, WebBeansContext webBeansContext, Class beanClass) {
super(beanClass, toSessionType(beanContext.getComponentType()), webBeansContext);
this.beanContext = beanContext;
beanContext.set(Bean.class, this);
}
@Override // copied to be able to produce EM (should be fixed in OWB for next CDI spec)
public void validatePassivationDependencies() {
if(isPassivationCapable()) {
final Set<InjectionPoint> beanInjectionPoints = getInjectionPoints();
for(InjectionPoint injectionPoint : beanInjectionPoints) {
if(!injectionPoint.isTransient()) {
if(!getWebBeansContext().getWebBeansUtil().isPassivationCapableDependency(injectionPoint)) {
if(injectionPoint.getAnnotated().isAnnotationPresent(Disposes.class)
// here is the hack, this is temporary until OWB manages correctly serializable instances
|| EntityManager.class.equals(injectionPoint.getAnnotated().getBaseType())) {
continue;
}
throw new WebBeansConfigurationException(
"Passivation capable beans must satisfy passivation capable dependencies. " +
"Bean : " + toString() + " does not satisfy. Details about the Injection-point: " +
injectionPoint.toString());
}
}
}
}
//Check for interceptors and decorators, copied from parent(s)
for (Decorator<?> dec : decorators) {
WebBeansDecorator<?> decorator = (WebBeansDecorator<?>) dec;
if (!decorator.isPassivationCapable()) {
throw new WebBeansConfigurationException(MessageFormat.format(
WebBeansLoggerFacade.getTokenString(OWBLogConst.EXCEPT_0015), toString()));
} else {
decorator.validatePassivationDependencies();
}
}
for (InterceptorData interceptorData : interceptorStack) {
if (interceptorData.isDefinedWithWebBeansInterceptor()) {
WebBeansInterceptor<?> interceptor = (WebBeansInterceptor<?>) interceptorData.getWebBeansInterceptor();
if (!interceptor.isPassivationCapable()) {
throw new WebBeansConfigurationException(MessageFormat.format(
WebBeansLoggerFacade.getTokenString(OWBLogConst.EXCEPT_0016), toString()));
} else {
interceptor.validatePassivationDependencies();
}
} else {
if (interceptorData.isDefinedInInterceptorClass()) {
Class<?> interceptorClass = interceptorData.getInterceptorClass();
if (!Serializable.class.isAssignableFrom(interceptorClass)) {
throw new WebBeansConfigurationException(MessageFormat.format(
WebBeansLoggerFacade.getTokenString(OWBLogConst.EXCEPT_0016), toString()));
} else {
if (!getWebBeansContext().getAnnotationManager().checkInjectionPointForInterceptorPassivation(interceptorClass)) {
throw new WebBeansConfigurationException(MessageFormat.format(
WebBeansLoggerFacade.getTokenString(OWBLogConst.EXCEPT_0017), toString(), interceptorClass));
}
}
}
}
}
}
@Override
public void addApiType(final Class<?> apiType) {
if (apiType == null) return;
super.addApiType(apiType);
}
public BeanContext getBeanContext() {
return this.beanContext;
}
private static SessionBeanType toSessionType(BeanType beanType) {
switch (beanType) {
case SINGLETON:
return SessionBeanType.SINGLETON;
case MESSAGE_DRIVEN: // OWB implementation test stateful or not so do we really care?
case STATELESS:
return SessionBeanType.STATELESS;
case STATEFUL:
case MANAGED:
return SessionBeanType.STATEFUL;
default:
throw new IllegalStateException("Unknown Session BeanType " + beanType);
}
}
@Override
public String getId() {
return beanContext.getDeploymentID() + getReturnType().getName();
}
@Override
protected void afterConstructor(T instance, CreationalContext<T> tCreationalContext) {
// no-op
}
// @Override
// public void postConstruct(T instance, CreationalContext<T> cretionalContext) {
// }
public String getEjbName() {
return this.beanContext.getEjbName();
}
public boolean needsBeanLocalViewAddedToTypes() {
return beanContext.isLocalbean() && beanContext.getBeanClass().getAnnotation(Typed.class) == null;
}
@Override
@SuppressWarnings("unchecked")
public List<Class<?>> getBusinessLocalInterfaces() {
final List<Class<?>> clazzes = new ArrayList<Class<?>>();
if (beanContext.isLocalbean()) {
addApiTypes(clazzes, beanContext.getBeanClass());
}
if (beanContext.getProxyClass() != null) {
addApiTypes(clazzes, beanContext.getProxyClass());
}
final List<Class> cl = beanContext.getBusinessLocalInterfaces();
if (cl != null && !cl.isEmpty()) {
for (Class<?> c : cl) {
clazzes.add(c);
}
}
if (!clazzes.contains(Serializable.class)) {
clazzes.add(Serializable.class);
}
return clazzes;
}
private static void addApiTypes(final List<Class<?>> clazzes, final Class<?> beanClass) {
final Typed typed = beanClass.getAnnotation(Typed.class);
if (typed == null || typed.value().length == 0) {
clazzes.add(beanClass);
} else {
for (Class<?> clazz : typed.value()) {
clazzes.add(clazz);
}
}
}
@Override
@SuppressWarnings("unchecked")
protected T getInstance(final CreationalContext<T> creationalContext) {
return createEjb(creationalContext);
/*
final T instance;
if (scopeClass == null || Dependent.class == scopeClass) { // no need to add any layer, null = @New
instance = createEjb(creationalContext);
} else { // only stateful normally
final InstanceBean<T> bean = new InstanceBean<T>(this);
if (webBeansContext.getBeanManagerImpl().isScopeTypeNormal(scopeClass)) {
instance = (T) webBeansContext.getProxyFactory().createNormalScopedBeanProxy(bean, creationalContext);
} else {
final Context context = webBeansContext.getBeanManagerImpl().getContext(scopeClass);
instance = context.get(bean, creationalContext);
}
bean.setOWBProxy(instance);
}
return instance;
*/
}
@Override
protected void destroyComponentInstance(final T instance, final CreationalContext<T> creational) {
if (scopeClass == null || Dependent.class == scopeClass) {
destroyStatefulSessionBeanInstance(instance, creational);
} else {
destroyScopedStateful(instance, creational);
}
}
@Override
protected void destroyStatefulSessionBeanInstance(final T proxyInstance, final Object ejbInstance) {
if (proxyInstance instanceof BeanContext.Removable) {
try {
((BeanContext.Removable) proxyInstance).$$remove();
} catch (NoSuchEJBException nsee) {
// no-op
} catch (UndeclaredThrowableException nsoe) {
if (!(nsoe.getCause() instanceof NoSuchObjectException)) {
throw nsoe;
}
} catch (Exception e) {
if (!(e instanceof NoSuchObjectException)) {
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
}
throw new OpenEJBRuntimeException(e);
}
}
}
}
@Override
public List<Method> getRemoveMethods() {
// Should we delegate to super and merge both?
if (beanContext.isLocalbean()) {
return findRemove(beanContext.getBeanClass(), beanContext.getBeanClass());
}
return findRemove(beanContext.getBeanClass(), beanContext.getBusinessLocalInterface());
}
public List<InjectionPoint> getInjectionPoint(Member member)
{
if (member instanceof Method) {
Method method = (Method) member;
member = beanContext.getMatchingBeanMethod(method);
}
List<InjectionPoint> points = new ArrayList<InjectionPoint>();
for(InjectionPoint ip : injectionPoints)
{
if(ip.getMember().equals(member))
{
points.add(ip);
}
}
return points;
}
protected void specialize(CdiEjbBean<?> superBean) {
final CdiEjbBean<T> bean = this;
bean.setName(superBean.getName());
bean.setSerializable(superBean.isSerializable());
this.scopeClass = superBean.scopeClass;
this.implQualifiers.addAll(superBean.getQualifiers());
this.stereoTypeClasses.addAll(superBean.stereoTypeClasses);
this.stereoTypes.addAll(superBean.stereoTypes);
}
/* (non-Javadoc)
* @see org.apache.webbeans.component.AbstractBean#isPassivationCapable()
*/
@Override
public boolean isPassivationCapable() {
return getWebBeansContext().getBeanManagerImpl().isPassivatingScope(getScope());
}
@SuppressWarnings("unchecked")
private List<Method> findRemove(Class beanClass, Class beanInterface) {
List<Method> toReturn = new ArrayList<Method>();
// Get all the public methods of the bean class and super class
Method[] methods = beanClass.getMethods();
// Search for methods annotated with @Remove
for (Method method : methods) {
Remove annotation = method.getAnnotation(Remove.class);
if (annotation != null) {
// Get the corresponding method into the bean interface
Method interfaceMethod;
try {
interfaceMethod = beanInterface.getMethod(method.getName(), method
.getParameterTypes());
toReturn.add(interfaceMethod);
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
// The method can not be into the interface in which case we
// don't wonder of
}
}
}
return toReturn;
}
protected T createEjb(final CreationalContext<T> creationalContext) {
final List<Class> classes = beanContext.getBusinessLocalInterfaces();
final CurrentCreationalContext currentCreationalContext = beanContext.get(CurrentCreationalContext.class);
final CreationalContext existing = currentCreationalContext.get();
currentCreationalContext.set(creationalContext);
try {
if (classes.size() == 0 && beanContext.isLocalbean()) {
final BeanContext.BusinessLocalBeanHome home = beanContext.getBusinessLocalBeanHome();
return (T) home.create();
} else {
final Class<?> mainInterface = classes.get(0);
final List<Class> interfaces = ProxyInterfaceResolver.getInterfaces(beanContext.getBeanClass(), mainInterface, classes);
final BeanContext.BusinessLocalHome home = beanContext.getBusinessLocalHome(interfaces, mainInterface);
return (T) home.create();
}
} finally {
currentCreationalContext.set(existing);
}
}
private void destroyScopedStateful(final T instance, final CreationalContext<T> cc) {
try {
instance.hashCode(); // force the instance to be created - otherwise we'll miss @PreDestroy for instance
} catch (NoSuchEJBException e) {
logger.log(Level.FINE, "The stateful instance " + instance + " can't be removed since it was invalidated", e);
return;
}
Object ejbInstance = dependentSFSBToBeRemoved.remove(System.identityHashCode(instance));
if (ejbInstance != null) {
destroyStatefulSessionBeanInstance((T) ejbInstance, cc);
} else {
destroyStatefulSessionBeanInstance(instance, cc);
}
}
public void storeStatefulInstance(final Object proxy, final T instance) {
dependentSFSBToBeRemoved.put(System.identityHashCode(proxy), instance);
}
}