private String fixTypes2(
ArrayList<TypeVar> scc, HashSet<String> lowersSet, org.hotswap.agent.javassist.ClassPool cp)
throws org.hotswap.agent.javassist.NotFoundException {
Iterator<String> it = lowersSet.iterator();
if (lowersSet.size() == 0) {
return null; // only NullType
} else if (lowersSet.size() == 1) {
return it.next();
} else {
org.hotswap.agent.javassist.CtClass cc = cp.get(it.next());
while (it.hasNext()) {
cc = commonSuperClassEx(cc, cp.get(it.next()));
}
if (cc.getSuperclass() == null || isObjectArray(cc)) {
cc = fixByUppers(scc, cp, new HashSet<TypeVar>(), cc);
}
if (cc.isArray()) {
return org.hotswap.agent.javassist.bytecode.Descriptor.toJvmName(cc);
} else {
return cc.getName();
}
}
}
/** Finds the most specific common super class of the given classes by considering array types. */
public static org.hotswap.agent.javassist.CtClass commonSuperClassEx(
org.hotswap.agent.javassist.CtClass one, org.hotswap.agent.javassist.CtClass two)
throws org.hotswap.agent.javassist.NotFoundException {
if (one == two) {
return one;
} else if (one.isArray() && two.isArray()) {
org.hotswap.agent.javassist.CtClass ele1 = one.getComponentType();
org.hotswap.agent.javassist.CtClass ele2 = two.getComponentType();
org.hotswap.agent.javassist.CtClass element = commonSuperClassEx(ele1, ele2);
if (element == ele1) {
return one;
} else if (element == ele2) {
return two;
} else {
return one.getClassPool()
.get(element == null ? "java.lang.Object" : element.getName() + "[]");
}
} else if (one.isPrimitive() || two.isPrimitive()) {
return null; // TOP
} else if (one.isArray() || two.isArray()) {
// two.isArray())
return one.getClassPool().get("java.lang.Object");
} else {
return commonSuperClass(one, two);
}
}
@OnClassLoadEvent(classNameRegexp = ".*", events = LoadEvent.REDEFINE)
public void entityReload(ClassLoader classLoader, CtClass clazz, Class original) {
if (AnnotationHelper.hasAnnotation(original, PATH_ANNOTATION)
|| AnnotationHelper.hasAnnotation(clazz, PATH_ANNOTATION)) {
LOGGER.debug(
"Reload @Path annotated class {}, original classloader {}",
clazz.getName(),
original.getClassLoader());
refresh(classLoader, 500);
}
}
/** Run plugin the method. */
public void onWatchEvent(
PluginAnnotation<T> pluginAnnotation, WatchFileEvent event, ClassLoader classLoader) {
final T annot = pluginAnnotation.getAnnotation();
Object plugin = pluginAnnotation.getPlugin();
// regular files filter
if (watchEventDTO.isOnlyRegularFiles() && !event.isFile()) {
LOGGER.trace("Skipping URI {} because it is not a regular file.", event.getURI());
return;
}
// watch type filter
if (!Arrays.asList(watchEventDTO.getEvents()).contains(event.getEventType())) {
LOGGER.trace("Skipping URI {} because it is not a requested event.", event.getURI());
return;
}
// resource name filter regexp
if (watchEventDTO.getFilter() != null && watchEventDTO.getFilter().length() > 0) {
if (!event.getURI().toString().matches(watchEventDTO.getFilter())) {
LOGGER.trace(
"Skipping URI {} because it does not match filter.",
event.getURI(),
watchEventDTO.getFilter());
return;
}
}
// we may need to crate CtClass on behalf of the client and close it after invocation.
CtClass ctClass = null;
// class file regexp
if (watchEventDTO.isClassFileEvent()) {
try {
// TODO creating class only to check name may slow down if lot of handlers is in use.
ctClass = createCtClass(event.getURI(), classLoader);
} catch (Exception e) {
LOGGER.error("Unable create CtClass for URI '{}'.", e, event.getURI());
return;
}
// unable to create CtClass or it's name does not match
if (ctClass == null || !ctClass.getName().matches(watchEventDTO.getClassNameRegexp())) return;
}
LOGGER.debug(
"Executing resource changed method {} on class {} for event {}",
pluginAnnotation.getMethod().getName(),
plugin.getClass().getName(),
event);
List<Object> args = new ArrayList<Object>();
for (Class<?> type : pluginAnnotation.getMethod().getParameterTypes()) {
if (type.isAssignableFrom(ClassLoader.class)) {
args.add(classLoader);
} else if (type.isAssignableFrom(URI.class)) {
args.add(event.getURI());
} else if (type.isAssignableFrom(URL.class)) {
try {
args.add(event.getURI().toURL());
} catch (MalformedURLException e) {
LOGGER.error("Unable to convert URI '{}' to URL.", e, event.getURI());
return;
}
} else if (type.isAssignableFrom(ClassPool.class)) {
args.add(ClassPool.getDefault());
} else if (type.isAssignableFrom(FileEvent.class)) {
args.add(event.getEventType());
} else if (watchEventDTO.isClassFileEvent() && type.isAssignableFrom(CtClass.class)) {
args.add(ctClass);
} else if (watchEventDTO.isClassFileEvent() && type.isAssignableFrom(String.class)) {
args.add(ctClass.getName());
} else {
LOGGER.error(
"Unable to call method {} on plugin {}. Method parameter type {} is not recognized.",
pluginAnnotation.getMethod().getName(),
plugin.getClass().getName(),
type);
return;
}
}
try {
pluginAnnotation.getMethod().invoke(plugin, args.toArray());
// close CtClass if created from here
if (ctClass != null) {
ctClass.detach();
}
} catch (IllegalAccessException e) {
LOGGER.error(
"IllegalAccessException in method {} on plugin {}",
e,
pluginAnnotation.getMethod().getName(),
plugin.getClass().getName());
} catch (InvocationTargetException e) {
LOGGER.error(
"InvocationTargetException in method {} on plugin {}",
e,
pluginAnnotation.getMethod().getName(),
plugin.getClass().getName());
}
}
static boolean eq(
org.hotswap.agent.javassist.CtClass one, org.hotswap.agent.javassist.CtClass two) {
return one == two || one != null && two != null && one.getName().equals(two.getName());
}
