private org.apache.openejb.api.EjbDeployment getEjbDeploymentAnnotation(
final EjbModule ejbModule, final EnterpriseBean bean) {
try {
final Class<?> beanClass = ejbModule.getClassLoader().loadClass(bean.getEjbClass());
return beanClass.getAnnotation(org.apache.openejb.api.EjbDeployment.class);
} catch (final ClassNotFoundException e) {
// this should never happen, the class has already been loaded a ton of times by this point
// unfortunately we have some unit tests that prevent us from throwing an exception just in
// case
// Those are OpenEjb2ConversionTest and SunCmpConversionTest
return null;
}
}
private String formatDeploymentId(
final EnterpriseBean bean,
final Map<String, String> contextData,
final StringTemplate template) {
contextData.put("ejbType", bean.getClass().getSimpleName());
contextData.put("ejbClass", bean.getEjbClass());
// we don't have the ejb class object (only the string name) so we have
// to extract the simple name from the FQN of the class
final int simpleNameIdx = bean.getEjbClass().lastIndexOf(".");
contextData.put("ejbClass.simpleName", bean.getEjbClass().substring(simpleNameIdx + 1));
contextData.put("ejbName", bean.getEjbName());
final String name = template.apply(contextData);
if (bean
instanceof
CompManagedBean) { // avoid conflict in ear between an ejbmodule and a war using the same
// name
return name + System.identityHashCode(bean);
}
return name;
}
private EjbModule deploy(
final EjbModule ejbModule,
final Map<String, String> contextData,
final Set<String> abstractSchemaNames)
throws OpenEJBException {
contextData.put("moduleId", ejbModule.getModuleId());
contextData.put("moduleUri", ejbModule.getModuleUri().toString());
final OpenejbJar openejbJar;
if (ejbModule.getOpenejbJar() != null) {
openejbJar = ejbModule.getOpenejbJar();
} else {
openejbJar = new OpenejbJar();
ejbModule.setOpenejbJar(openejbJar);
}
StringTemplate deploymentIdTemplate = this.deploymentIdTemplate;
if (openejbJar.getProperties().containsKey(DEPLOYMENT_ID_FORMAT)) {
final String format = openejbJar.getProperties().getProperty(DEPLOYMENT_ID_FORMAT);
logger.info("Using " + DEPLOYMENT_ID_FORMAT + " '" + format + "'");
deploymentIdTemplate = new StringTemplate(format);
}
for (final EnterpriseBean bean : ejbModule.getEjbJar().getEnterpriseBeans()) {
StringTemplate template = deploymentIdTemplate;
final org.apache.openejb.api.EjbDeployment annotation =
getEjbDeploymentAnnotation(ejbModule, bean);
EjbDeployment ejbDeployment = openejbJar.getDeploymentsByEjbName().get(bean.getEjbName());
if (ejbDeployment == null) {
ejbDeployment = new EjbDeployment();
ejbDeployment.setEjbName(bean.getEjbName());
if (annotation != null && isDefined(annotation.id())) {
template = new StringTemplate(annotation.id());
ejbDeployment.setDeploymentId(formatDeploymentId(bean, contextData, template));
} else {
ejbDeployment.setDeploymentId(formatDeploymentId(bean, contextData, template));
if (!(bean instanceof ManagedBean) || !((ManagedBean) bean).isHidden()) {
logger.info(
"Auto-deploying ejb "
+ bean.getEjbName()
+ ": EjbDeployment(deployment-id="
+ ejbDeployment.getDeploymentId()
+ ")");
}
}
openejbJar.getEjbDeployment().add(ejbDeployment);
} else if (ejbDeployment.getDeploymentId() == null) {
if (annotation != null && isDefined(annotation.id())) {
template = new StringTemplate(annotation.id());
ejbDeployment.setDeploymentId(formatDeploymentId(bean, contextData, template));
} else {
ejbDeployment.setDeploymentId(formatDeploymentId(bean, contextData, template));
logger.info(
"Auto-assigning deployment-id for ejb "
+ bean.getEjbName()
+ ": EjbDeployment(deployment-id="
+ ejbDeployment.getDeploymentId()
+ ")");
}
}
if (ejbDeployment.getContainerId() == null
&& annotation != null
&& isDefined(annotation.container())) {
ejbDeployment.setContainerId(annotation.container());
}
if (isCmpEntity(bean)) {
final EntityBean entity = (EntityBean) bean;
if (entity.getAbstractSchemaName() == null) {
String abstractSchemaName = bean.getEjbName().trim().replaceAll("[ \\t\\n\\r-]+", "_");
// The AbstractSchemaName must be unique, we should check that it is
if (abstractSchemaNames.contains(abstractSchemaName)) {
int i = 2;
while (abstractSchemaNames.contains(abstractSchemaName + i)) {
i++;
}
abstractSchemaName = abstractSchemaName + i;
}
abstractSchemaNames.add(abstractSchemaName);
entity.setAbstractSchemaName(abstractSchemaName);
}
}
}
return ejbModule;
}
public EjbJarInfo buildInfo(final EjbModule jar) throws OpenEJBException {
deploymentIds.clear();
securityRoles.clear();
final Map<String, EjbDeployment> ejbds = jar.getOpenejbJar().getDeploymentsByEjbName();
final int beansDeployed = jar.getOpenejbJar().getEjbDeploymentCount();
final int beansInEjbJar = jar.getEjbJar().getEnterpriseBeans().length;
if (beansInEjbJar != beansDeployed) {
for (final EnterpriseBean bean : jar.getEjbJar().getEnterpriseBeans()) {
if (!ejbds.containsKey(bean.getEjbName())) {
ConfigUtils.logger.warning("conf.0018", bean.getEjbName(), jar.getJarLocation());
}
}
final String message =
messages.format(
"conf.0008",
jar.getJarLocation(),
String.valueOf(beansInEjbJar),
String.valueOf(beansDeployed));
logger.warning(message);
throw new OpenEJBException(message);
}
final Map<String, EnterpriseBeanInfo> infos = new HashMap<String, EnterpriseBeanInfo>();
final Map<String, EnterpriseBean> items = new HashMap<String, EnterpriseBean>();
final EjbJarInfo ejbJar = new EjbJarInfo();
ejbJar.path = jar.getJarLocation();
ejbJar.moduleUri = jar.getModuleUri();
ejbJar.moduleId = jar.getModuleId();
if (jar.getEjbJar() != null && jar.getEjbJar().getModuleName() != null) {
ejbJar.moduleName = jar.getEjbJar().getModuleName();
} else {
ejbJar.moduleName = jar.getModuleId();
}
ejbJar.watchedResources.addAll(jar.getWatchedResources());
ejbJar.properties.putAll(jar.getProperties());
ejbJar.properties.putAll(jar.getOpenejbJar().getProperties());
for (final EnterpriseBean bean : jar.getEjbJar().getEnterpriseBeans()) {
final EnterpriseBeanInfo beanInfo;
if (bean instanceof SessionBean) {
beanInfo = initSessionBean((SessionBean) bean, ejbJar, ejbds);
} else if (bean instanceof EntityBean) {
beanInfo = initEntityBean((EntityBean) bean, ejbds);
} else if (bean instanceof MessageDrivenBean) {
beanInfo = initMessageBean((MessageDrivenBean) bean, ejbds);
} else {
throw new OpenEJBException("Unknown bean type: " + bean.getClass().getName());
}
ejbJar.enterpriseBeans.add(beanInfo);
if (deploymentIds.contains(beanInfo.ejbDeploymentId)) {
final String message =
messages.format(
"conf.0100", beanInfo.ejbDeploymentId, jar.getJarLocation(), beanInfo.ejbName);
logger.warning(message);
throw new OpenEJBException(message);
}
deploymentIds.add(beanInfo.ejbDeploymentId);
beanInfo.codebase = jar.getJarLocation();
infos.put(beanInfo.ejbName, beanInfo);
items.put(beanInfo.ejbName, bean);
if (bean.getSecurityIdentity() != null) {
beanInfo.runAs = bean.getSecurityIdentity().getRunAs();
final EjbDeployment deployment = ejbds.get(beanInfo.ejbName);
if (deployment != null) {
for (final RoleMapping mapping : deployment.getRoleMapping()) {
if (mapping.getRoleName().equals(beanInfo.runAs)) {
beanInfo.runAsUser = mapping.getPrincipalName();
break;
}
}
}
}
initJndiNames(ejbds, beanInfo);
}
if (jar.getEjbJar().getAssemblyDescriptor() != null) {
initInterceptors(jar, ejbJar);
initSecurityRoles(jar, ejbJar);
initMethodPermissions(jar, ejbds, ejbJar);
initExcludesList(jar, ejbds, ejbJar);
initMethodTransactions(jar, ejbds, ejbJar);
initMethodConcurrency(jar, ejbds, ejbJar);
initApplicationExceptions(jar, ejbJar);
for (final EnterpriseBeanInfo bean : ejbJar.enterpriseBeans) {
resolveRoleLinks(bean, items.get(bean.ejbName));
}
}
if (jar.getEjbJar().getRelationships() != null) {
initRelationships(jar, infos);
}
final Beans beans = jar.getBeans();
if (beans != null) {
ejbJar.beans = new BeansInfo();
ejbJar.beans.version = beans.getVersion();
ejbJar.beans.discoveryMode = beans.getBeanDiscoveryMode();
if (beans.getScan() != null) {
for (final Beans.Scan.Exclude exclude : beans.getScan().getExclude()) {
final ExclusionInfo exclusionInfo = new ExclusionInfo();
for (final Object config :
exclude.getIfClassAvailableOrIfClassNotAvailableOrIfSystemProperty()) {
if (Beans.Scan.Exclude.IfAvailableClassCondition.class.isInstance(config)) {
exclusionInfo.availableClasses.add(
Beans.Scan.Exclude.ClassCondition.class.cast(config).getName());
} else if (Beans.Scan.Exclude.IfNotAvailableClassCondition.class.isInstance(config)) {
exclusionInfo.notAvailableClasses.add(
Beans.Scan.Exclude.ClassCondition.class.cast(config).getName());
} else if (Beans.Scan.Exclude.IfSystemProperty.class.isInstance(config)) {
final Beans.Scan.Exclude.IfSystemProperty systemProperty =
Beans.Scan.Exclude.IfSystemProperty.class.cast(config);
if (systemProperty.getValue() == null) {
exclusionInfo.systemPropertiesPresence.add(systemProperty.getName());
} else {
exclusionInfo.systemProperties.put(
systemProperty.getName(), systemProperty.getValue());
}
} else {
throw new IllegalArgumentException("Not supported: " + config);
}
}
final BeansInfo.ExclusionEntryInfo exclusionEntryInfo =
new BeansInfo.ExclusionEntryInfo();
exclusionEntryInfo.name = exclude.getName();
exclusionEntryInfo.exclusion = exclusionInfo;
ejbJar.beans.excludes.add(exclusionEntryInfo);
}
}
ejbJar.beans.interceptors.addAll(beans.getInterceptors());
ejbJar.beans.decorators.addAll(beans.getDecorators());
ejbJar.beans.alternativeClasses.addAll(beans.getAlternativeClasses());
ejbJar.beans.alternativeStereotypes.addAll(beans.getAlternativeStereotypes());
ejbJar.beans.duplicatedAlternativeClasses.addAll(
beans.getDuplicatedAlternatives().getClasses());
ejbJar.beans.duplicatedAlternativeStereotypes.addAll(
beans.getDuplicatedAlternatives().getStereotypes());
ejbJar.beans.duplicatedInterceptors.addAll(beans.getDuplicatedInterceptors());
ejbJar.beans.duplicatedDecorators.addAll(beans.getDuplicatedDecorators());
ejbJar.beans.startupClasses.addAll(beans.getStartupBeans());
final Map<URL, String> discoveryModeByUrl = new HashMap<>();
if (CompositeBeans.class.isInstance(beans)) {
discoveryModeByUrl.putAll(CompositeBeans.class.cast(beans).getDiscoveryByUrl());
} else {
discoveryModeByUrl.put(null, beans.getBeanDiscoveryMode());
}
for (final Map.Entry<URL, List<String>> next : beans.getManagedClasses().entrySet()) {
final URL key = next.getKey();
final BeansInfo.BDAInfo bdaInfo = new BeansInfo.BDAInfo();
bdaInfo.managedClasses.addAll(next.getValue());
bdaInfo.discoveryMode = discoveryModeByUrl.get(key);
try {
bdaInfo.uri = key == null ? null : key.toURI();
} catch (final URISyntaxException e) {
bdaInfo.uri = null;
}
ejbJar.beans.bdas.add(bdaInfo);
}
}
return ejbJar;
}
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());
}
}
}
}