private void copyConcurrentMethods(
final SessionBean bean, final EjbJarInfo ejbJarInfo, final Map ejbds) {
for (final ConcurrentMethod method : bean.getConcurrentMethod()) {
final MethodConcurrencyInfo info = new MethodConcurrencyInfo();
if (method.getLock() != null) {
info.concurrencyAttribute = method.getLock().toString();
}
info.accessTimeout = toInfo(method.getAccessTimeout());
final Method m = new Method(bean.getEjbName(), null, method.getMethod().getMethodName());
m.setMethodParams(method.getMethod().getMethodParams());
info.methods.add(getMethodInfo(m, ejbds));
ejbJarInfo.methodConcurrency.add(info);
}
}
private EnterpriseBeanInfo initSessionBean(
final SessionBean s, final EjbJarInfo ejbJar, final Map m) throws OpenEJBException {
EnterpriseBeanInfo bean = null;
if (s.getSessionType() == SessionType.STATEFUL) {
bean = new StatefulBeanInfo();
bean.passivable = s.getPassivationCapable();
final StatefulBeanInfo stateful = (StatefulBeanInfo) bean;
copyCallbacks(s.getPostActivate(), stateful.postActivate);
copyCallbacks(s.getPrePassivate(), stateful.prePassivate);
copyCallbacks(s.getAfterBegin(), stateful.afterBegin);
copyCallbacks(s.getBeforeCompletion(), stateful.beforeCompletion);
copyCallbacks(s.getAfterCompletion(), stateful.afterCompletion);
for (final InitMethod initMethod : s.getInitMethod()) {
final InitMethodInfo init = new InitMethodInfo();
init.beanMethod = toInfo(initMethod.getBeanMethod());
init.createMethod = toInfo(initMethod.getCreateMethod());
stateful.initMethods.add(init);
}
for (final RemoveMethod removeMethod : s.getRemoveMethod()) {
final RemoveMethodInfo remove = new RemoveMethodInfo();
remove.beanMethod = toInfo(removeMethod.getBeanMethod());
remove.retainIfException = removeMethod.getRetainIfException();
stateful.removeMethods.add(remove);
}
copyConcurrentMethods(s, ejbJar, m);
} else if (s.getSessionType() == SessionType.MANAGED) {
bean = new ManagedBeanInfo();
final ManagedBeanInfo managed = (ManagedBeanInfo) bean;
if (s
instanceof
ManagedBean) { // this way we support managed beans in ejb-jar.xml (not in the spec but
// can be useful)
managed.hidden = ((ManagedBean) s).isHidden();
} else {
managed.hidden = true;
}
copyCallbacks(s.getPostActivate(), managed.postActivate);
copyCallbacks(s.getPrePassivate(), managed.prePassivate);
for (final RemoveMethod removeMethod : s.getRemoveMethod()) {
final RemoveMethodInfo remove = new RemoveMethodInfo();
remove.beanMethod = toInfo(removeMethod.getBeanMethod());
remove.retainIfException = removeMethod.getRetainIfException();
managed.removeMethods.add(remove);
}
} else if (s.getSessionType() == SessionType.SINGLETON) {
bean = new SingletonBeanInfo();
final ConcurrencyManagementType type = s.getConcurrencyManagementType();
bean.concurrencyType =
type != null ? type.toString() : ConcurrencyManagementType.CONTAINER.toString();
bean.loadOnStartup = s.getInitOnStartup();
copyCallbacks(s.getAroundTimeout(), bean.aroundTimeout);
copySchedules(s.getTimer(), bean.methodScheduleInfos);
// See JndiEncInfoBuilder.buildDependsOnRefs for processing of DependsOn
// bean.dependsOn.addAll(s.getDependsOn());
copyConcurrentMethods(s, ejbJar, m);
} else {
bean = new StatelessBeanInfo();
copySchedules(s.getTimer(), bean.methodScheduleInfos);
}
if (s.getSessionType() != SessionType.STATEFUL) {
copyCallbacks(s.getAroundTimeout(), bean.aroundTimeout);
}
bean.localbean = s.getLocalBean() != null;
bean.timeoutMethod = toInfo(s.getTimeoutMethod());
copyCallbacks(s.getAroundInvoke(), bean.aroundInvoke);
copyCallbacks(s.getPostConstruct(), bean.postConstruct);
copyCallbacks(s.getPreDestroy(), bean.preDestroy);
copyAsynchronous(s.getAsyncMethod(), bean.asynchronous);
bean.asynchronousClasses.addAll(s.getAsynchronousClasses());
final EjbDeployment d = (EjbDeployment) m.get(s.getEjbName());
if (d == null) {
throw new OpenEJBException(
"No deployment information in openejb-jar.xml for bean "
+ s.getEjbName()
+ ". Please redeploy the jar");
}
bean.ejbDeploymentId = d.getDeploymentId();
bean.containerId = d.getContainerId();
final Icon icon = s.getIcon();
bean.largeIcon = icon == null ? null : icon.getLargeIcon();
bean.smallIcon = icon == null ? null : icon.getSmallIcon();
bean.description = s.getDescription();
bean.displayName = s.getDisplayName();
bean.ejbClass = s.getEjbClass();
bean.ejbName = s.getEjbName();
bean.home = s.getHome();
bean.remote = s.getRemote();
bean.localHome = s.getLocalHome();
bean.local = s.getLocal();
bean.proxy = s.getProxy();
bean.parents.addAll(s.getParents());
bean.businessLocal.addAll(s.getBusinessLocal());
bean.businessRemote.addAll(s.getBusinessRemote());
final TransactionType txType = s.getTransactionType();
bean.transactionType =
txType != null ? txType.toString() : TransactionType.CONTAINER.toString();
bean.serviceEndpoint = s.getServiceEndpoint();
bean.properties.putAll(d.getProperties());
bean.statefulTimeout = toInfo(s.getStatefulTimeout());
bean.restService = s.isRestService() && !(s instanceof StatefulBean);
return bean;
}
public void validate(EjbModule module) {
Set<String> applicationExceptions = new HashSet<String>();
for (ApplicationException applicationException :
module.getEjbJar().getAssemblyDescriptor().getApplicationException()) {
applicationExceptions.add(applicationException.getExceptionClass());
}
for (EnterpriseBean bean : module.getEjbJar().getEnterpriseBeans()) {
Class<?> ejbClass = null;
try {
ejbClass = loadClass(bean.getEjbClass());
} catch (OpenEJBException e) {
continue;
}
if (bean instanceof SessionBean) {
SessionBean session = (SessionBean) bean;
for (AsyncMethod asyncMethod : session.getAsyncMethod()) {
Method method = getMethod(ejbClass, asyncMethod);
if (method == null) {
fail(
bean,
"asynchronous.missing",
asyncMethod.getMethodName(),
ejbClass.getName(),
getParameters(asyncMethod.getMethodParams()));
} else {
checkAsynchronousMethod(session, ejbClass, method, applicationExceptions);
}
}
for (String className : session.getAsynchronousClasses()) {
try {
Class<?> cls = loadClass(className);
for (Method method : cls.getDeclaredMethods()) {
if (Modifier.isPublic(method.getModifiers()) && !method.isSynthetic()) {
checkAsynchronousMethod(session, ejbClass, method, applicationExceptions);
} else {
// warn(session, "asynchronous.methodignored", ejbClass.getName(),
// method.getName());
}
}
} catch (OpenEJBException e) {
// ignore ?
}
}
} else {
ClassFinder classFinder = new ClassFinder(ejbClass);
for (Method method : classFinder.findAnnotatedMethods(Asynchronous.class)) {
ignoredMethodAnnotation(
"Asynchronous",
bean,
bean.getEjbClass(),
method.getName(),
bean.getClass().getSimpleName());
}
if (ejbClass.getAnnotation(Asynchronous.class) != null) {
ignoredClassAnnotation(
"Asynchronous", bean, bean.getEjbClass(), bean.getClass().getSimpleName());
}
}
}
}