@Override
public void setResources(final WebResourceRoot resources) {
this.resources = resources;
if (StandardRoot.class.isInstance(resources)) {
final List<WebResourceSet> jars =
(List<WebResourceSet>) Reflections.get(resources, "jarResources");
if (jars != null && !jars.isEmpty()) {
final Iterator<WebResourceSet> jarIt = jars.iterator();
while (jarIt.hasNext()) {
final WebResourceSet set = jarIt.next();
if (set.getBaseUrl() == null) {
continue;
}
final File file = URLs.toFile(set.getBaseUrl());
try {
if (file.exists()
&& (!TomEEClassLoaderEnricher.validateJarFile(file) || !jarIsAccepted(file))) {
// need to remove this resource
LOGGER.warning("Removing " + file.getAbsolutePath() + " since it is offending");
jarIt.remove();
}
} catch (final IOException e) {
// ignore
}
}
}
}
}
public static ValidatorFactory buildFactory(
final ValidationInfo config, final ClassLoader classLoader) {
ValidatorFactory factory = null;
final Thread thread = Thread.currentThread();
final ClassLoader oldContextLoader = thread.getContextClassLoader();
try {
thread.setContextClassLoader(classLoader);
if (config == null) {
factory = Validation.buildDefaultValidatorFactory();
} else {
final Configuration<?> configuration = getConfig(config);
try {
factory = configuration.buildValidatorFactory();
} catch (final ValidationException ve) {
thread.setContextClassLoader(ValidatorBuilder.class.getClassLoader());
factory = Validation.buildDefaultValidatorFactory();
thread.setContextClassLoader(classLoader);
logger.warning(
"Unable create validator factory with config "
+ config
+ " ("
+ ve.getMessage()
+ ")."
+ " Default factory will be used.");
}
}
} finally {
thread.setContextClassLoader(oldContextLoader);
}
return factory;
}
@Override
public void contextInitialized(ServletContextEvent servletContextEvent) {
try {
OpenEJBLifecycle.initializeServletContext(
servletContextEvent.getServletContext(), webBeansContext);
} catch (final Exception e) {
logger.warning(e.getMessage(), e);
}
ensureRequestScope();
}
public DeployTimeEnhancer() {
Method mtd;
Constructor<?> cstr;
final ClassLoader cl = DeployTimeEnhancer.class.getClassLoader();
try {
final Class<?> enhancerClass = cl.loadClass("org.apache.openjpa.enhance.PCEnhancer");
final Class<?> arg2 = cl.loadClass("org.apache.openjpa.lib.util.Options");
cstr = arg2.getConstructor(Properties.class);
mtd = enhancerClass.getMethod("run", String[].class, arg2);
} catch (Exception e) {
LOGGER.warning("openjpa enhancer can't be found in the container, will be skipped");
mtd = null;
cstr = null;
}
optionsConstructor = cstr;
enhancerMethod = mtd;
}
private boolean jarIsAccepted(final File file) {
if (configurer == null) {
return true;
}
try {
if (!configurer.accept(file.toURI().toURL())) {
LOGGER.warning(
"jar '"
+ file.getAbsolutePath()
+ "' is excluded: "
+ file.getName()
+ ". It will be ignored.");
return false;
}
} catch (final MalformedURLException e) {
// no-op
}
return true;
}
public DynamicMBeanWrapper(final WebBeansContext wc, final Object givenInstance) {
Class<?> annotatedMBean = givenInstance.getClass();
// javaassist looses annotation so simply unwrap it
if (wc != null) {
if (givenInstance.getClass().getName().contains("$Owb")) { // isProxy
annotatedMBean = annotatedMBean.getSuperclass();
}
}
classloader = annotatedMBean.getClassLoader();
instance = givenInstance;
final CacheInfo cache = CACHE.get(annotatedMBean);
if (cache == null) {
final String description;
final List<MBeanAttributeInfo> attributeInfos = new ArrayList<MBeanAttributeInfo>();
final List<MBeanOperationInfo> operationInfos = new ArrayList<MBeanOperationInfo>();
final List<MBeanNotificationInfo> notificationInfos = new ArrayList<MBeanNotificationInfo>();
// class
final Description classDescription = findAnnotation(annotatedMBean, Description.class);
description = getDescription(classDescription, "a MBean built by OpenEJB");
final NotificationInfo notification = findAnnotation(annotatedMBean, NotificationInfo.class);
if (notification != null) {
final MBeanNotificationInfo notificationInfo = getNotificationInfo(notification);
notificationInfos.add(notificationInfo);
}
final NotificationInfos notifications =
findAnnotation(annotatedMBean, NotificationInfos.class);
if (notifications != null && notifications.value() != null) {
for (final NotificationInfo n : notifications.value()) {
final MBeanNotificationInfo notificationInfo = getNotificationInfo(n);
notificationInfos.add(notificationInfo);
}
}
// methods
for (final Method m : annotatedMBean.getMethods()) {
final int modifiers = m.getModifiers();
if (m.getDeclaringClass().equals(Object.class)
|| !Modifier.isPublic(modifiers)
|| Modifier.isAbstract(modifiers)) {
continue;
}
if (findAnnotation(m, ManagedAttribute.class) != null) {
final String methodName = m.getName();
String attrName = methodName;
if ((attrName.startsWith("get") && m.getParameterTypes().length == 0
|| attrName.startsWith("set") && m.getParameterTypes().length == 1)
&& attrName.length() > 3) {
attrName = attrName.substring(3);
if (attrName.length() > 1) {
attrName = Character.toLowerCase(attrName.charAt(0)) + attrName.substring(1);
} else {
attrName = attrName.toLowerCase();
}
} else {
logger.warning(
"ignoring attribute " + m.getName() + " for " + annotatedMBean.getName());
}
if (methodName.startsWith("get")) {
getters.put(attrName, m);
} else if (methodName.startsWith("set")) {
setters.put(attrName, m);
}
} else if (findAnnotation(m, ManagedOperation.class) != null) {
operations.put(m.getName(), m);
String operationDescr = "";
final Description descr = findAnnotation(m, Description.class);
if (descr != null) {
operationDescr = getDescription(descr, "-");
}
operationInfos.add(newMethodDescriptor(operationDescr, m));
}
}
for (final Map.Entry<String, Method> e : getters.entrySet()) {
final String key = e.getKey();
final Method mtd = e.getValue();
String attrDescr = "";
final Description descr = findAnnotation(mtd, Description.class);
if (descr != null) {
attrDescr = getDescription(descr, "-");
}
try {
attributeInfos.add(new MBeanAttributeInfo(key, attrDescr, mtd, setters.get(key)));
} catch (final IntrospectionException ex) {
logger.warning("can't manage " + key + " for " + mtd.getName(), ex);
}
}
// for updatable but not readable attributes
for (final Map.Entry<String, Method> e : setters.entrySet()) {
final String key = e.getKey();
if (getters.get(key) != null) {
continue; // already done
}
final Method mtd = e.getValue();
String attrDescr = "";
final Description descr = findAnnotation(mtd, Description.class);
if (descr != null) {
attrDescr = getDescription(descr, "-");
}
try {
attributeInfos.add(new MBeanAttributeInfo(key, attrDescr, null, setters.get(key)));
} catch (final IntrospectionException ex) {
logger.warning("can't manage " + key + " for " + mtd.getName(), ex);
}
}
info =
new MBeanInfo(
annotatedMBean.getName(),
description,
attributeInfos.toArray(new MBeanAttributeInfo[attributeInfos.size()]),
null, // default constructor is mandatory
operationInfos.toArray(new MBeanOperationInfo[operationInfos.size()]),
notificationInfos.toArray(new MBeanNotificationInfo[notificationInfos.size()]));
if (annotatedMBean.getAnnotation(Internal.class) != null) {
CACHE.put(annotatedMBean, new CacheInfo(info, getters, setters, operations));
}
} else {
info = cache.mBeanInfo;
getters.putAll(cache.getters);
setters.putAll(cache.setters);
operations.putAll(cache.operations);
}
}
public void enhance(@Observes final BeforeDeploymentEvent event) {
if (enhancerMethod == null) {
LOGGER.debug("OpenJPA is not available so no deploy-time enhancement will be done");
return;
}
// find persistence.xml
final Map<String, List<String>> classesByPXml = new HashMap<String, List<String>>();
final List<URL> usedUrls = new ArrayList<URL>(); // for fake classloader
for (URL url : event.getUrls()) {
final File file = URLs.toFile(url);
if (file.isDirectory()) {
final String pXmls = getWarPersistenceXml(url);
if (pXmls != null) {
feed(classesByPXml, pXmls);
}
usedUrls.add(url);
} else if (file.getName().endsWith(".jar")) {
try {
final JarFile jar = new JarFile(file);
ZipEntry entry = jar.getEntry(META_INF_PERSISTENCE_XML);
if (entry != null) {
final String path = file.getAbsolutePath();
final File unpacked =
new File(path.substring(0, path.length() - 4) + TMP_ENHANCEMENT_SUFFIX);
JarExtractor.extract(file, unpacked);
// replace jar by folder url since otherwise enhancement doesn't work
usedUrls.add(unpacked.toURI().toURL());
feed(classesByPXml, new File(unpacked, META_INF_PERSISTENCE_XML).getAbsolutePath());
}
} catch (IOException e) {
// ignored
}
} else {
usedUrls.add(url);
}
}
// enhancement
final ClassLoader tccl = Thread.currentThread().getContextClassLoader();
final ClassLoader fakeClassLoader =
new URLClassLoaderFirst(
usedUrls.toArray(new URL[usedUrls.size()]), event.getParentClassLoader());
Thread.currentThread().setContextClassLoader(fakeClassLoader);
try {
for (Map.Entry<String, List<String>> entry : classesByPXml.entrySet()) {
final Properties opts = new Properties();
opts.setProperty(PROPERTIES_FILE_PROP, entry.getKey());
final Object optsArg;
try {
optsArg = optionsConstructor.newInstance(opts);
} catch (Exception e) {
LOGGER.debug("can't create options for enhancing");
return;
}
LOGGER.info("enhancing url(s): " + Arrays.asList(event.getUrls()));
try {
enhancerMethod.invoke(null, toFilePaths(entry.getValue()), optsArg);
} catch (Exception e) {
LOGGER.warning("can't enhanced at deploy-time entities", e);
}
}
} finally {
Thread.currentThread().setContextClassLoader(tccl);
usedUrls.clear();
}
// clean up extracted jars and replace jar to keep consistent classloading
for (Map.Entry<String, List<String>> entry : classesByPXml.entrySet()) {
final List<String> values = entry.getValue();
for (String rawPath : values) {
if (rawPath.endsWith(TMP_ENHANCEMENT_SUFFIX + "/")
|| rawPath.endsWith(TMP_ENHANCEMENT_SUFFIX)) {
final File dir = new File(rawPath);
final File file =
new File(
rawPath.substring(0, rawPath.length() - TMP_ENHANCEMENT_SUFFIX.length() - 1)
+ ".jar");
if (file.exists()) {
String name = dir.getName();
name = name.substring(0, name.length() - TMP_ENHANCEMENT_SUFFIX.length()) + ".jar";
final File target = new File(dir.getParentFile(), name);
try { // override existing jar otherwise classloading is broken in tomee
Files.delete(file);
JarCreator.jarDir(dir, target);
} catch (final IOException e) {
LOGGER.error("can't repackage enhanced jar file " + file.getName());
}
Files.delete(dir);
}
}
}
values.clear();
}
classesByPXml.clear();
}
@SuppressWarnings("unchecked")
private static Configuration<?> getConfig(final ValidationInfo info) {
Configuration<?> target = null;
final Thread thread = Thread.currentThread();
final ClassLoader classLoader = thread.getContextClassLoader();
String providerClassName = info.providerClassName;
if (providerClassName == null) {
providerClassName =
SystemInstance.get().getOptions().get(VALIDATION_PROVIDER_KEY, (String) null);
}
if (providerClassName != null) {
try {
@SuppressWarnings({"unchecked", "rawtypes"})
final Class clazz = classLoader.loadClass(providerClassName);
target = Validation.byProvider(clazz).configure();
logger.info("Using " + providerClassName + " as validation provider.");
} catch (final ClassNotFoundException e) {
logger.warning("Unable to load provider class " + providerClassName, e);
} catch (final ValidationException ve) {
logger.warning(
"Unable create validator factory with provider "
+ providerClassName
+ " ("
+ ve.getMessage()
+ ")."
+ " Default one will be used.");
}
}
if (target == null) {
// force to use container provider to ignore any conflicting configuration
thread.setContextClassLoader(ValidatorBuilder.class.getClassLoader());
target = Validation.byDefaultProvider().configure();
thread.setContextClassLoader(classLoader);
}
final Set<ExecutableType> types = new HashSet<>();
for (final String type : info.validatedTypes) {
types.add(ExecutableType.valueOf(type));
}
final Map<String, String> props = new HashMap<>();
for (final Map.Entry<Object, Object> entry : info.propertyTypes.entrySet()) {
final PropertyType property = new PropertyType();
property.setName((String) entry.getKey());
property.setValue((String) entry.getValue());
props.put(property.getName(), property.getValue());
if (logger.isDebugEnabled()) {
logger.debug(
"Found property '" + property.getName() + "' with value '" + property.getValue());
}
target.addProperty(property.getName(), property.getValue());
}
final OpenEjbBootstrapConfig bootstrapConfig =
new OpenEjbBootstrapConfig(
providerClassName,
info.constraintFactoryClass,
info.messageInterpolatorClass,
info.traversableResolverClass,
info.parameterNameProviderClass,
new HashSet<>(info.constraintMappings),
info.executableValidationEnabled,
types,
props);
final OpenEjbConfig config = new OpenEjbConfig(bootstrapConfig, target);
target.ignoreXmlConfiguration();
final String messageInterpolatorClass = info.messageInterpolatorClass;
if (messageInterpolatorClass != null) {
try {
@SuppressWarnings("unchecked")
final Class<MessageInterpolator> clazz =
(Class<MessageInterpolator>) classLoader.loadClass(messageInterpolatorClass);
target.messageInterpolator(newInstance(config, clazz));
} catch (final Exception e) {
logger.warning(
"Unable to set " + messageInterpolatorClass + " as message interpolator.", e);
}
logger.info("Using " + messageInterpolatorClass + " as message interpolator.");
}
final String traversableResolverClass = info.traversableResolverClass;
if (traversableResolverClass != null) {
try {
@SuppressWarnings("unchecked")
final Class<TraversableResolver> clazz =
(Class<TraversableResolver>) classLoader.loadClass(traversableResolverClass);
target.traversableResolver(newInstance(config, clazz));
} catch (final Exception e) {
logger.warning(
"Unable to set " + traversableResolverClass + " as traversable resolver.", e);
}
logger.info("Using " + traversableResolverClass + " as traversable resolver.");
}
final String constraintFactoryClass = info.constraintFactoryClass;
if (constraintFactoryClass != null) {
try {
@SuppressWarnings("unchecked")
final Class<ConstraintValidatorFactory> clazz =
(Class<ConstraintValidatorFactory>) classLoader.loadClass(constraintFactoryClass);
target.constraintValidatorFactory(newInstance(config, clazz));
} catch (final Exception e) {
logger.warning("Unable to set " + constraintFactoryClass + " as constraint factory.", e);
}
logger.info("Using " + constraintFactoryClass + " as constraint factory.");
}
for (final String mappingFileName : info.constraintMappings) {
if (logger.isDebugEnabled()) {
logger.debug("Opening input stream for " + mappingFileName);
}
final InputStream in = classLoader.getResourceAsStream(mappingFileName);
if (in == null) {
logger.warning(
"Unable to open input stream for mapping file "
+ mappingFileName
+ ". It will be ignored");
} else {
target.addMapping(in);
}
}
if (info.parameterNameProviderClass != null) {
try {
final Class<ParameterNameProvider> clazz =
(Class<ParameterNameProvider>) classLoader.loadClass(info.parameterNameProviderClass);
target.parameterNameProvider(newInstance(config, clazz));
} catch (final Exception e) {
logger.warning(
"Unable to set " + info.parameterNameProviderClass + " as parameter name provider.", e);
}
logger.info("Using " + info.parameterNameProviderClass + " as parameter name provider.");
}
return config;
}
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;
}
static {
boolean result = ClassLoader.registerAsParallelCapable();
if (!result) {
LOGGER.warning("Can't register // tomee webapp classloader");
}
}