/* | |
* 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 WARRANTIESOR 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.aries.jpa.container.weaving.impl; | |
import java.util.ArrayList; | |
import java.util.Collection; | |
import java.util.Collections; | |
import java.util.HashMap; | |
import java.util.LinkedHashSet; | |
import java.util.Map; | |
import javax.persistence.spi.ClassTransformer; | |
import org.osgi.framework.Bundle; | |
import org.osgi.framework.hooks.weaving.WeavingException; | |
import org.osgi.framework.hooks.weaving.WeavingHook; | |
import org.osgi.framework.hooks.weaving.WovenClass; | |
import org.osgi.framework.wiring.BundleWiring; | |
import org.slf4j.Logger; | |
import org.slf4j.LoggerFactory; | |
/** | |
* This weaving hook delegates to any registered {@link ClassTransformer} instances for a given bundle | |
*/ | |
public class JPAWeavingHook implements WeavingHook, TransformerRegistry { | |
private static final Logger LOGGER = LoggerFactory.getLogger(JPAWeavingHook.class); | |
/** | |
* This constructor should not be called directly, the {@link JPAWeavingHookFactory} should be used to | |
* ensure that Weaving support is available. | |
*/ | |
JPAWeavingHook() { | |
} | |
/** | |
* With luck we will only have one persistence unit per bundle, but if we don't we'll need to call them | |
* until one of them does a transform or we run out. | |
*/ | |
private final Map<Bundle, LinkedHashSet<ClassTransformer>> registeredTransformers = new HashMap<Bundle, LinkedHashSet<ClassTransformer>>(); | |
public void weave(WovenClass wovenClass) { | |
BundleWiring wiring = wovenClass.getBundleWiring(); | |
Bundle bundle = wiring.getBundle(); | |
ClassLoader cl = wiring.getClassLoader(); | |
Collection<ClassTransformer> transformersToTry = getTransformers(bundle); | |
if (transformersToTry.size() == 0 && wovenClass.getClassName().endsWith("Car")) { | |
LOGGER.error("Loading " + wovenClass.getClassName() + " before transformer is present"); | |
//for (StackTraceElement el : Thread.currentThread().getStackTrace()) { | |
// LOGGER.info(el.toString()); | |
// } | |
} | |
for (ClassTransformer transformer : transformersToTry) { | |
if (transformClass(wovenClass, cl, transformer)) { | |
LOGGER.info("Weaving " + wovenClass.getClassName() + " using " + transformer.getClass().getName()); | |
break; | |
}; | |
} | |
} | |
@SuppressWarnings("unchecked") | |
private synchronized Collection<ClassTransformer> getTransformers(Bundle bundle) { | |
LinkedHashSet<ClassTransformer> transformers = registeredTransformers.get(bundle); | |
return transformers != null ? new ArrayList<ClassTransformer>(transformers) : Collections.EMPTY_LIST; | |
} | |
private boolean transformClass(WovenClass wovenClass, ClassLoader cl, ClassTransformer transformer) | |
throws ThreadDeath, OutOfMemoryError { | |
try { | |
byte[] result = transformer | |
.transform(cl, | |
wovenClass.getClassName(), | |
wovenClass.getDefinedClass(), | |
wovenClass.getProtectionDomain(), | |
wovenClass.getBytes()); | |
if (result != null) { | |
wovenClass.setBytes(result); | |
wovenClass.getDynamicImports().add("org.eclipse.persistence.*"); | |
wovenClass.getDynamicImports().add("org.apache.openjpa.*"); | |
return true; | |
} | |
} catch (Throwable t) { | |
if (t instanceof ThreadDeath) | |
throw (ThreadDeath)t; | |
else if (t instanceof OutOfMemoryError) | |
throw (OutOfMemoryError)t; | |
else { | |
Bundle b = wovenClass.getBundleWiring().getBundle(); | |
String msg = String.format("Weaving failure", wovenClass.getClassName(), | |
b.getSymbolicName(), b.getVersion(), transformer); | |
throw new WeavingException(msg, t); | |
} | |
} | |
return false; | |
} | |
public synchronized void addTransformer(Bundle pBundle, ClassTransformer transformer) { | |
LOGGER.info("Adding transformer " + transformer.getClass().getName()); | |
LinkedHashSet<ClassTransformer> transformers = registeredTransformers.get(pBundle); | |
if (transformers == null) { | |
transformers = new LinkedHashSet<ClassTransformer>(); | |
registeredTransformers.put(pBundle, transformers); | |
} | |
transformers.add(transformer); | |
} | |
public synchronized void removeTransformer(Bundle pBundle, ClassTransformer transformer) { | |
LinkedHashSet<ClassTransformer> set = registeredTransformers.get(pBundle); | |
if (set == null || !set.remove(transformer)) { | |
throw new IllegalStateException("Transformer " + transformer + " not registered"); | |
} | |
if (set.isEmpty()) { | |
registeredTransformers.remove(pBundle); | |
} | |
} | |
} |