proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-jbossmodules-plugin/src/main/java/org/hotswap/agent/plugin/jbossmodules/PrependingMap.java
|
PrependingMap
|
get
|
class PrependingMap implements Map {
private Map masterMap;
private Object prependList;
public PrependingMap(Map masterMap, Object prependList) {
this.masterMap = masterMap;
this.prependList = prependList;
}
@Override
public void clear() {
masterMap.clear();
}
@Override
public boolean containsKey(Object paramObject) {
return masterMap.containsKey(paramObject);
}
@Override
public boolean containsValue(Object paramObject) {
return masterMap.containsValue(paramObject);
}
@Override
public Set entrySet() {
return masterMap.entrySet();
}
@SuppressWarnings("unchecked")
@Override
public Object get(Object paramObject) {<FILL_FUNCTION_BODY>}
@Override
public boolean isEmpty() {
return masterMap.isEmpty();
}
@Override
public Set keySet() {
return masterMap.keySet();
}
@SuppressWarnings("unchecked")
@Override
public Object put(Object paramK, Object paramV) {
return masterMap.put(paramK, paramV);
}
@SuppressWarnings("unchecked")
@Override
public void putAll(Map paramMap) {
masterMap.putAll(paramMap);
}
@Override
public Object remove(Object paramObject) {
return masterMap.remove(paramObject);
}
@Override
public int size() {
return masterMap.size();
}
@Override
public Collection values() {
return masterMap.values();
}
}
|
Object list = masterMap.get(paramObject);
if (prependList != null) {
// TODO : is there any situation when there is no path registered in the ModuleClassLoader
// and prepending loader should be returned?
// if (list == null) {
// List result = new ArrayList();
// result.addAll((List) prependList);
// return result;
// }
if (list instanceof List){
List result = new ArrayList<>((List) prependList);
result.addAll((List)list);
return result;
}
}
return list;
| 439
| 152
| 591
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-jersey1-plugin/src/main/java/org/hotswap/agent/plugin/jersey1/Jersey1Plugin.java
|
Jersey1Plugin
|
invalidate
|
class Jersey1Plugin {
private static AgentLogger LOGGER = AgentLogger.getLogger(Jersey1Plugin.class);
@Init
Scheduler scheduler;
@Init
ClassLoader appClassLoader;
Set<Object> registeredJerseyContainers = Collections.newSetFromMap(new WeakHashMap<Object, Boolean>());
Set<Class<?>> allRegisteredClasses = Collections.newSetFromMap(new WeakHashMap<Class<?>, Boolean>());
/**
* Initialize the plugin when Jersey's ServletContainer.init(WebConfig config) is called. This is called from both init() for a servlet
* and init(Config) for a filter.
*
* Also, add the ServletContainer to a list of registeredJerseyContainers so that we can call reload on it later when classes change
*/
@OnClassLoadEvent(classNameRegexp = "com.sun.jersey.spi.container.servlet.ServletContainer")
public static void jerseyServletCallInitialized(CtClass ctClass, ClassPool classPool) throws NotFoundException, CannotCompileException {
CtMethod init = ctClass.getDeclaredMethod("init", new CtClass[] { classPool.get("com.sun.jersey.spi.container.servlet.WebConfig") });
init.insertBefore(PluginManagerInvoker.buildInitializePlugin(Jersey1Plugin.class));
LOGGER.info("com.sun.jersey.spi.container.servlet.WebConfig enhanced with plugin initialization.");
String registerThis = PluginManagerInvoker.buildCallPluginMethod(Jersey1Plugin.class, "registerJerseyContainer", "this",
"java.lang.Object", "this.webComponent.getResourceConfig()", "java.lang.Object");
init.insertAfter(registerThis);
}
/**
* Register the jersey container and the classes involved in configuring the Jersey Application
*/
public void registerJerseyContainer(Object jerseyContainer, Object resourceConfig) {
try {
Class<?> resourceConfigClass = resolveClass("com.sun.jersey.api.core.ResourceConfig");
LOGGER.info("Jersey1 plugin - registerJerseyContainer : " + jerseyContainer.getClass().getName());
Set<Class<?>> containerClasses = getContainerClasses(resourceConfigClass, resourceConfig);
registeredJerseyContainers.add(jerseyContainer);
allRegisteredClasses.addAll(containerClasses);
LOGGER.debug("registerJerseyContainer : finished");
} catch (Exception e) {
LOGGER.error("Error registering Jersey Container.", e);
}
}
/**
* Gets a list of classes used in configure the Jersey Application
*/
private Set<Class<?>> getContainerClasses(Class<?> resourceConfigClass, Object resourceConfig)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
Set<Class<?>> containerClasses = Collections.newSetFromMap(new WeakHashMap<Class<?>, Boolean>());
Set<Class<?>> providerClasses = (Set<Class<?>>) ReflectionHelper.invoke(resourceConfig, resourceConfigClass, "getProviderClasses", new Class[]{});
if (providerClasses != null) {
containerClasses.addAll(providerClasses);
}
Set<Class<?>> rootResourceClasses = (Set<Class<?>>) ReflectionHelper.invoke(resourceConfig, resourceConfigClass, "getRootResourceClasses", new Class[]{});
if (rootResourceClasses != null) {
containerClasses.addAll(rootResourceClasses);
}
return containerClasses;
}
/**
* Call reload on the jersey Application when any class changes that is either involved in configuring
* the Jersey Application, or if was newly annotated and will be involved in configuring the application.
*/
@OnClassLoadEvent(classNameRegexp = ".*", events = LoadEvent.REDEFINE)
public void invalidate(CtClass ctClass, Class original) throws Exception {<FILL_FUNCTION_BODY>}
/**
* Call reload on the Jersey Application
*/
private Command reloadJerseyContainers = new Command() {
public void executeCommand() {
try {
Class<?> containerClass = resolveClass("com.sun.jersey.spi.container.servlet.ServletContainer");
Method reloadMethod = containerClass.getDeclaredMethod("reload");
for (Object jerseyContainer : registeredJerseyContainers) {
reloadMethod.invoke(jerseyContainer);
}
LOGGER.info("Reloaded Jersey Containers");
} catch (Exception e) {
LOGGER.error("Error reloading Jersey Container.", e);
}
}
};
private Class<?> resolveClass(String name) throws ClassNotFoundException {
return Class.forName(name, true, appClassLoader);
}
}
|
if (allRegisteredClasses.contains(original)) {
scheduler.scheduleCommand(reloadJerseyContainers);
} else {
// TODO: When a class is not annotated at startup, and is annotated during debug, it never gets found
// here. Is this a DCEVM issue? Also, the Jersey Container does not find the newly annotated class
// during a reload called from reloadJerseyContainers, so this seems like the annotation is not being
// added
// vd: it is wrong here, since original class is scanned for Path !
if (AnnotationHelper.hasAnnotation(original, "javax.ws.rs.Path")
|| AnnotationHelper.hasAnnotation(ctClass, "javax.ws.rs.Path")) {
allRegisteredClasses.add(original);
scheduler.scheduleCommand(reloadJerseyContainers);
}
}
| 1,251
| 228
| 1,479
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-jetty-plugin/src/main/java/org/hotswap/agent/plugin/jetty/JettyPlugin.java
|
JettyPlugin
|
init
|
class JettyPlugin {
private static AgentLogger LOGGER = AgentLogger.getLogger(JettyPlugin.class);
@Init
PluginConfiguration pluginConfiguration;
/**
* Plugin initialization step needs to be fine tuned. It can be intialized only AFTER the classloader
* already knows about hotswap-agent.properties file (i.e. after webapp basic path is added to the classloader),
* but BEFORE first servlet is initialized.
*
* WebXmlConfiguration seems to be good place which should work in most setups. The plugin is intialized before
* web.xml file is processed - basic paths should be known, but nothing is processed yet.
*
* Application classloader is processed during plugin initialization. It means that other plugins triggered
* on plugin init should fire as well - for jetty is important core watchResources plugin, which will handle
* extraClassPath and watchResources configuration properties (jetty fortunately depends only on basic
* URLClassLoader behaviour which is handled by that plugin).
*/
@OnClassLoadEvent(classNameRegexp = "org.eclipse.jetty.webapp.WebXmlConfiguration")
public static void patchWebXmlConfiguration(CtClass ctClass) throws NotFoundException, CannotCompileException, ClassNotFoundException {
try {
// after application context initialized, but before processing started
CtMethod doStart = ctClass.getDeclaredMethod("configure");
// init the plugin
String src = PluginManagerInvoker.buildInitializePlugin(JettyPlugin.class, "context.getClassLoader()");
src += PluginManagerInvoker.buildCallPluginMethod("context.getClassLoader()", JettyPlugin.class,
"init", "context", "java.lang.Object");
doStart.insertBefore(src);
} catch (NotFoundException e) {
LOGGER.warning("org.eclipse.jetty.webapp.WebAppContext does not contain startContext method. Jetty plugin will be disabled.\n" +
"*** This is Ok, Jetty plugin handles only special properties ***");
return;
}
}
// same as above for older jetty versions
@OnClassLoadEvent(classNameRegexp = "org.mortbay.jetty.webapp.WebXmlConfiguration")
public static void patchWebXmlConfiguration6x(CtClass ctClass) throws NotFoundException, CannotCompileException, ClassNotFoundException {
try {
// after application context initialized, but before processing started
CtMethod doStart = ctClass.getDeclaredMethod("configureWebApp");
// init the plugin
String src = PluginManagerInvoker.buildInitializePlugin(JettyPlugin.class, "getWebAppContext().getClassLoader()");
src += PluginManagerInvoker.buildCallPluginMethod("getWebAppContext().getClassLoader()", JettyPlugin.class,
"init", "getWebAppContext()", "java.lang.Object");
doStart.insertBefore(src);
} catch (NotFoundException e) {
LOGGER.warning("org.mortbay.jetty.webapp.WebXmlConfiguration does not contain startContext method. Jetty plugin will be disabled.\n" +
"*** This is Ok, Jetty plugin handles only special properties ***");
return;
}
}
/**
* Before app context is stopped, clean the classloader (and associated plugin instance).
*/
@OnClassLoadEvent(classNameRegexp = "(org.mortbay.jetty.webapp.WebAppContext)|(org.eclipse.jetty.webapp.WebAppContext)")
public static void patchContextHandler6x(CtClass ctClass) throws NotFoundException, CannotCompileException, ClassNotFoundException {
try {
ctClass.getDeclaredMethod("doStop").insertBefore(
PluginManagerInvoker.buildCallCloseClassLoader("getClassLoader()")
);
} catch (NotFoundException e) {
LOGGER.debug("org.eclipse.jetty.webapp.WebAppContext does not contain doStop() method. Hotswap agent will not be able to free Jetty plugin resources.");
}
}
/**
* Actual plugin initialization write plugin info and handle webappDir property.
*
* If the webappDir property is set, call:
* <pre>
* contextHandler.setBaseResource(new ResourceCollection(
* new FileResource(webappDir),
* contextHandler.getBaseResource()
* ));
*</pre>
* @param contextHandler instance of ContextHandler - main jetty class for webapp.
*/
public void init(Object contextHandler) {<FILL_FUNCTION_BODY>}
}
|
// resolve jetty classes
ClassLoader loader = contextHandler.getClass().getClassLoader();
Class contextHandlerClass;
Class resourceClass;
Class fileResourceClass;
Class resourceCollectionClass;
try {
contextHandlerClass = loader.loadClass("org.eclipse.jetty.server.handler.ContextHandler");
resourceClass = loader.loadClass("org.eclipse.jetty.util.resource.Resource");
fileResourceClass = loader.loadClass("org.eclipse.jetty.util.resource.FileResource");
resourceCollectionClass = loader.loadClass("org.eclipse.jetty.util.resource.ResourceCollection");
} catch (ClassNotFoundException e) {
try {
contextHandlerClass = loader.loadClass("org.mortbay.jetty.handler.ContextHandler");
resourceClass = loader.loadClass("org.mortbay.resource.Resource");
fileResourceClass = loader.loadClass("org.mortbay.resource.FileResource");
resourceCollectionClass = loader.loadClass("org.mortbay.resource.ResourceCollection");
} catch (ClassNotFoundException e1) {
LOGGER.error("Unable to load ContextHandler class from contextHandler {} classloader", contextHandler);
return;
}
}
String version;
// find version in Servlet package (http://docs.codehaus.org/display/JETTY/How+to+find+out+the+version+of+Jetty)
try {
Object server = ReflectionHelper.invoke(contextHandler, contextHandlerClass, "getServer", new Class[]{});
version = server.getClass().getPackage().getImplementationVersion();
} catch (Exception e) {
version = "unknown [" + e.getMessage() + "]";
}
// set different resource
URL[] webappDir = pluginConfiguration.getWebappDir();
if (webappDir.length > 0) {
try {
Object originalBaseResource = ReflectionHelper.invoke(contextHandler, contextHandlerClass,
"getBaseResource", new Class[] {});
Object resourceArray = Array.newInstance(resourceClass, webappDir.length + 1);
for (int i = 0; i < webappDir.length; i++) {
LOGGER.debug("Watching 'webappDir' for changes: {} in Jetty webapp: {}", webappDir[i],
contextHandler);
Object fileResource = fileResourceClass.getDeclaredConstructor(URL.class).newInstance(webappDir[i]);
Array.set(resourceArray, i, fileResource);
}
Array.set(resourceArray, webappDir.length, originalBaseResource);
Object resourceCollection = resourceCollectionClass.getDeclaredConstructor(resourceArray.getClass())
.newInstance(resourceArray);
ReflectionHelper.invoke(contextHandler, contextHandlerClass, "setBaseResource",
new Class[] { resourceClass }, resourceCollection);
} catch (Exception e) {
LOGGER.error(
"Unable to set webappDir to directory '{}' for Jetty webapp {}. This configuration will not work.",
e, webappDir[0], contextHandler);
}
}
LOGGER.info("Jetty plugin initialized - Jetty version '{}', context {}", version, contextHandler);
| 1,161
| 804
| 1,965
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-log4j2-plugin/src/main/java/org/hotswap/agent/plugin/log4j2/Log4j2Plugin.java
|
Log4j2Plugin
|
init
|
class Log4j2Plugin {
private static final AgentLogger LOGGER = AgentLogger.getLogger(Log4j2Plugin.class);
@Init
Watcher watcher;
@Init
ClassLoader appClassLoader;
// ensure uri registered only once
Set<URI> registeredURIs = new HashSet<>();
volatile boolean initialized;
/**
* Callback method from
* org.apache.logging.log4j.core.LoggerContext.setConfiguration(Configuration)
*
* @param config the Log4j2 configuration object
*/
public void init(final Object config) {<FILL_FUNCTION_BODY>}
/**
* Do the reload using Log4j2 configurator.
*
* @param uri the configuration file uri
*/
protected void reload(URI uri) {
try {
IOUtils.toByteArray(uri);
} catch (Exception e) {
LOGGER.warning("Unable to open Log4j2 configuration file {}, is it deleted?", uri);
return;
}
try {
Class<?> logManagerClass = appClassLoader.loadClass("org.apache.logging.log4j.LogManager");
Class<?> contextClass = appClassLoader.loadClass("org.apache.logging.log4j.core.LoggerContext");
Object context = logManagerClass.getDeclaredMethod("getContext", Boolean.TYPE).invoke(logManagerClass,
true);
// resetting configLocation forces reconfiguration
contextClass.getDeclaredMethod("setConfigLocation", URI.class).invoke(context, uri);
LOGGER.reload("Log4j2 configuration reloaded from uri '{}'.", uri);
} catch (Exception e) {
LOGGER.error("Unable to reload {} with Log4j2", e, uri);
}
}
@OnClassLoadEvent(classNameRegexp = "org.apache.logging.log4j.core.LoggerContext")
public static void registerConfigurator(ClassPool classPool, CtClass ctClass) throws NotFoundException,
CannotCompileException {
// fallback to the old version (<2.3) of Log4j2
CtMethod m = ctClass.getDeclaredMethod("setConfiguration",
new CtClass[] { classPool.get("org.apache.logging.log4j.core.config.Configuration") });
m.insertAfter(PluginManagerInvoker.buildInitializePlugin(Log4j2Plugin.class));
m.insertAfter(PluginManagerInvoker.buildCallPluginMethod(Log4j2Plugin.class, "init",
"$1", "java.lang.Object"));
}
}
|
URI configURI = null;
String url = null;
try {
Class<?> configurationClass = appClassLoader.loadClass("org.apache.logging.log4j.core.config.Configuration");
Class<?> configurationSourceClass = appClassLoader.loadClass("org.apache.logging.log4j.core.config.ConfigurationSource");
Object configurationSource = configurationClass.getDeclaredMethod("getConfigurationSource").invoke(config);
url = (String) configurationSourceClass.getDeclaredMethod("getLocation").invoke(configurationSource);
if (url == null) {
LOGGER.warning("Location url is NULL on configurationSource={} - exiting.", configurationSource);
} else {
configURI = Paths.get(url).toUri();
if (registeredURIs.contains(configURI)) {
return;
}
final URI parentUri = Paths.get(configURI).getParent().toUri();
LOGGER.debug("Watching '{}' URI for Log4j2 configuration changes.", configURI);
registeredURIs.add(configURI);
watcher.addEventListener(appClassLoader, parentUri, new WatchEventListener() {
@Override
public void onEvent(WatchFileEvent event) {
if (event.getEventType() != FileEvent.DELETE && registeredURIs.contains(event.getURI())) {
reload(event.getURI());
}
}
});
}
if (!initialized) {
LOGGER.info("Log4j2 plugin initialized.");
initialized = true;
}
} catch (java.nio.file.InvalidPathException e) {
LOGGER.debug("Cannot convert {} to Path", url);
} catch (Exception e) {
LOGGER.error("Exception initializing Log4j2 on uri {}.", e, configURI);
}
| 671
| 459
| 1,130
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-logback-plugin/src/main/java/org/hotswap/agent/plugin/logback/LogbackPlugin.java
|
LogbackPlugin
|
initLogback
|
class LogbackPlugin {
private static AgentLogger LOGGER = AgentLogger.getLogger(LogbackPlugin.class);
@Init
Watcher watcher;
@Init
ClassLoader appClassLoader;
// ensure uri registered only once
Set<URI> registeredURIs = new HashSet<URI>();
boolean initialized;
/**
* Callback method from ch.qos.logback.core.joran.GenericConfigurator.
*
* @param configurator the configurator object
* @param url configuration file url
*/
public void initLogback(final Object configurator, final URL url) {<FILL_FUNCTION_BODY>}
/**
* Do the reload using logback configurator.
*
* @param configurator ch.qos.logback.core.joran.GenericConfigurator instance
* @param url URL with configuration file
*/
protected void reload(Object configurator, URL url) {
try {
IOUtils.toByteArray(url.toURI());
} catch (Exception e) {
LOGGER.warning("Unable to open logback configuration file {}, is it deleted?", url);
return;
}
try {
//noinspection SynchronizationOnLocalVariableOrMethodParameter
synchronized (configurator) {
ClassLoader classLoader = configurator.getClass().getClassLoader();
Class<?> configuratorClass = classLoader.loadClass("ch.qos.logback.core.joran.GenericConfigurator");
Class<?> contextAwareBaseClass = classLoader.loadClass("ch.qos.logback.core.spi.ContextAwareBase");
Class<?> contextClass = classLoader.loadClass("ch.qos.logback.classic.LoggerContext");
// reset current context
Object context = contextAwareBaseClass.getDeclaredMethod("getContext").invoke(configurator);
contextClass.getDeclaredMethod("reset").invoke(context);
// configure the URL
configuratorClass.getDeclaredMethod("doConfigure", URL.class).invoke(configurator, url);
LOGGER.reload("Logback configuration reloaded from url '{}'.", url);
}
} catch (Exception e) {
LOGGER.error("Unable to reload {} with logback configurator {}", e, url, configurator);
}
}
/**
* Transform configurator class to register logback config URL.
*/
@OnClassLoadEvent(classNameRegexp = "ch.qos.logback.core.joran.GenericConfigurator")
public static void registerConfigurator(ClassPool classPool, CtClass ctClass) throws NotFoundException, CannotCompileException {
CtMethod m = ctClass.getDeclaredMethod("doConfigure", new CtClass[]{classPool.get("java.net.URL")});
m.insertAfter(PluginManagerInvoker.buildInitializePlugin(LogbackPlugin.class));
m.insertAfter(PluginManagerInvoker.buildCallPluginMethod(LogbackPlugin.class, "initLogback",
"this", "java.lang.Object",
"url", "java.net.URL"));
}
}
|
try {
final URI uri = url.toURI();
// skip double registration on reload
if (registeredURIs.contains(uri))
return;
LOGGER.debug("Watching '{}' URL for Logback configuration changes.", url);
registeredURIs.add(uri);
watcher.addEventListener(appClassLoader, uri, new WatchEventListener() {
@Override
public void onEvent(WatchFileEvent event) {
if (event.getEventType() != FileEvent.DELETE)
reload(configurator, url);
}
});
if (!initialized) {
LOGGER.info("Logback plugin initialized.");
initialized = true;
}
} catch (Exception e) {
LOGGER.error("Exception initializing logback configurator {} on url {}.", e, configurator, url);
}
| 804
| 214
| 1,018
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-mojarra-plugin/src/main/java/org/hotswap/agent/plugin/mojarra/MojarraPlugin.java
|
MojarraPlugin
|
executeCommand
|
class MojarraPlugin {
private static AgentLogger LOGGER = AgentLogger.getLogger(MojarraPlugin.class);
@Init
Scheduler scheduler;
@Init
ClassLoader appClassLoader;
Set<Object> registeredRBMaps = Collections.newSetFromMap(new WeakHashMap<Object, Boolean>());
@Init
public void init(PluginConfiguration pluginConfiguration) {
LOGGER.info("Mojarra plugin initialized.");
}
@OnClassLoadEvent(classNameRegexp = "com.sun.faces.config.ConfigManager")
public static void facesConfigManagerInitialized(CtClass ctClass) throws NotFoundException, CannotCompileException {
CtMethod init = ctClass.getDeclaredMethod("initialize");
init.insertAfter(PluginManagerInvoker.buildInitializePlugin(MojarraPlugin.class));
LOGGER.debug("com.sun.faces.config.ConfigManager enhanced with plugin initialization.");
}
@OnClassLoadEvent(classNameRegexp = "com.sun.faces.application.ApplicationResourceBundle")
public static void facesApplicationAssociateInitialized(CtClass ctClass) throws NotFoundException, CannotCompileException {
String registerResourceBundle = PluginManagerInvoker.buildCallPluginMethod(MojarraPlugin.class, "registerApplicationResourceBundle",
"baseName", "java.lang.String", "resources", "java.lang.Object");
String buildInitializePlugin = PluginManagerInvoker.buildInitializePlugin(MojarraPlugin.class);
for (CtConstructor constructor : ctClass.getDeclaredConstructors()) {
constructor.insertAfter(buildInitializePlugin);
constructor.insertAfter(registerResourceBundle);
}
LOGGER.debug("com.sun.faces.application.ApplicationAssociate enhanced with resource bundles registration.");
}
public void registerApplicationResourceBundle(String baseName, Object resourceBundle) {
registeredRBMaps.add(resourceBundle);
LOGGER.debug("JsfPlugin - resource bundle '" + baseName + "' registered");
}
@OnResourceFileEvent(path = "/", filter = ".*.properties")
public void refreshJsfResourceBundles() {
scheduler.scheduleCommand(refreshResourceBundles);
}
@OnClassLoadEvent(classNameRegexp = ".*", events = LoadEvent.REDEFINE)
public void reloadManagedBean(Class<?> beanClass) {
if (!AnnotationHelper.hasAnnotation(beanClass, MANAGED_BEAN_ANNOTATION)) {
return;
}
ReloadManagedBeanCommand command = new ReloadManagedBeanCommand(beanClass, appClassLoader);
scheduler.scheduleCommand(command);
}
@OnClassFileEvent(classNameRegexp = ".*", events = FileEvent.CREATE)
public void registerManagedBean(CtClass beanCtClass) throws Exception {
if (!AnnotationHelper.hasAnnotation(beanCtClass, MANAGED_BEAN_ANNOTATION)) {
return;
}
ReloadManagedBeanCommand command = new ReloadManagedBeanCommand(beanCtClass, appClassLoader);
scheduler.scheduleCommand(command);
}
private Command refreshResourceBundles = new Command() {
public void executeCommand() {<FILL_FUNCTION_BODY>}
};
private Class<?> resolveClass(String name) throws ClassNotFoundException {
return Class.forName(name, true, appClassLoader);
}
}
|
LOGGER.debug("Refreshing JSF resource bundles.");
try {
Class<?> clazz = resolveClass("java.util.ResourceBundle");
Method clearCacheMethod = clazz.getDeclaredMethod("clearCache", ClassLoader.class);
clearCacheMethod.invoke(null, appClassLoader);
for (Object resourceMap : registeredRBMaps) {
if (resourceMap instanceof Map) {
((Map) resourceMap).clear();
}
}
} catch (Exception e) {
LOGGER.error("Error clear JSF resource bundles cache", e);
}
| 874
| 149
| 1,023
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-mojarra-plugin/src/main/java/org/hotswap/agent/plugin/mojarra/command/ReloadManagedBeanCommand.java
|
ReloadManagedBeanCommand
|
executeCommand
|
class ReloadManagedBeanCommand implements Command {
private static AgentLogger LOGGER = AgentLogger.getLogger(ReloadManagedBeanCommand.class);
private CtClass beanCtClass;
private Class<?> beanClass;
private ClassLoader classLoader;
public ReloadManagedBeanCommand(Class<?> beanClass, ClassLoader classLoader) {
this.beanClass = beanClass;
this.classLoader = classLoader;
}
public ReloadManagedBeanCommand(CtClass beanCtClass, ClassLoader classLoader) {
this.beanCtClass = beanCtClass;
this.classLoader = classLoader;
}
@Override
public void executeCommand() {<FILL_FUNCTION_BODY>}
private boolean isBeanClassLoadedBefore() {
return beanClass != null;
}
@SuppressWarnings("deprecation")
private Class<?> getBeanClass() throws ClassNotFoundException, CannotCompileException {
if (!isBeanClassLoadedBefore()) {
// bean is not loaded yet. try to load the class..
return beanCtClass.toClass(classLoader);
}
return beanClass;
}
private Class<?> resolveClass(String name) throws ClassNotFoundException {
return Class.forName(name, true, classLoader);
}
}
|
try {
Class<?> beanClass = getBeanClass();
if (isBeanClassLoadedBefore()) {
LOGGER.info("Reloading managed bean: {}", beanClass.getName());
} else {
LOGGER.info("Registering new managed bean: {}", beanClass.getName());
}
Class<?> beanResolverClass = resolveClass(BEAN_MANAGER_CLASS);
ReflectionHelper.invoke(
null,
beanResolverClass,
"addToDirtyBeans",
new Class[] {Class.class},
new Object[] {beanClass}
);
} catch (Exception ex) {
LOGGER.info("Unable to reload managed bean. Reason: {}", ex.getMessage(), ex);
}
| 346
| 196
| 542
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-mojarra-plugin/src/main/java/org/hotswap/agent/plugin/mojarra/transformer/BeanManagerTransformer.java
|
BeanManagerTransformer
|
createGetManagedBeanInfoMethod
|
class BeanManagerTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(BeanManagerTransformer.class);
public static final String DIRTY_BEANS_FIELD = "DIRTY_BEANS";
public static CtClass MODIFIED_BEAN_MANAGER;
@OnClassLoadEvent(classNameRegexp = BEAN_MANAGER_CLASS)
public static void init(CtClass ctClass, ClassLoader classLoader) throws CannotCompileException, NotFoundException {
LOGGER.info("Patching bean manager. Class loader: {}", classLoader);
initClassPool(ctClass);
createDirtyBeansField(ctClass);
createAddToDirtyBeansMethod(ctClass);
createGetManagedBeanInfoMethod(ctClass);
createProcessDirtyBeansMethod(ctClass);
LOGGER.info("Patched bean manager successfully.");
MODIFIED_BEAN_MANAGER = ctClass;
}
private static void initClassPool(CtClass ctClass) {
ClassPool classPool = ctClass.getClassPool();
classPool.importPackage("com.sun.faces.mgbean");
classPool.importPackage("com.sun.faces.application.annotation");
classPool.importPackage("java.lang");
classPool.importPackage("java.util");
classPool.importPackage("java.util.concurrent");
classPool.importPackage("java.util.logging");
classPool.importPackage("javax.faces.context");
classPool.importPackage("javax.faces.bean");
classPool.importPackage("org.hotswap.agent.util");
}
/**
* Creates a field which holds dirty beans.
*/
private static void createDirtyBeansField(CtClass ctClass) throws CannotCompileException, NotFoundException {
CtField dirtyBeansField = CtField.make(
"public static List " + DIRTY_BEANS_FIELD + " = new ArrayList();" , ctClass
);
ctClass.addField(dirtyBeansField);
}
/**
* Creates a method which adds a managed bean class to dirty beans list.
*/
private static void createAddToDirtyBeansMethod(CtClass ctClass) throws CannotCompileException, NotFoundException {
CtMethod addToDirtyBeansMethod = CtMethod.make(
"public static synchronized void addToDirtyBeans(Class beanClass) {" +
DIRTY_BEANS_FIELD + ".add(beanClass);" +
"LOGGER.log(Level.INFO, \"Added to dirty beans.\");" +
"}",
ctClass
);
ctClass.addMethod(addToDirtyBeansMethod);
}
/**
* Creates a method which returns managed bean info with the
* {@link com.sun.faces.mgbean.ManagedBeanInfo.ManagedBeanInfo} format.
*/
private static void createGetManagedBeanInfoMethod(CtClass ctClass) throws CannotCompileException, NotFoundException {<FILL_FUNCTION_BODY>}
/**
* Creates a method which processes the dirty beans.
*/
private static void createProcessDirtyBeansMethod(CtClass ctClass) throws CannotCompileException, NotFoundException {
CtMethod processDirtyBeansMethod = CtMethod.make(
"public synchronized void processDirtyBeans() {" +
"FacesContext facesContext = FacesContext.getCurrentInstance(); " +
"if (facesContext == null) { "+
"return;" +
"}" +
"Iterator iterator = " + DIRTY_BEANS_FIELD + ".iterator(); "+
"while (iterator.hasNext()) {" +
"Class beanClass = (Class)iterator.next(); " +
"ManagedBeanInfo beanInfo = this.getManagedBeanInfo(beanClass); " +
"this.register(beanInfo); " +
"String beanName = beanInfo.getName(); " +
"BeanBuilder beanBuilder = this.getBuilder(beanName);" +
"this.preProcessBean(beanName, beanBuilder); " +
"this.create(beanName, facesContext); " +
"iterator.remove();" +
"LOGGER.log(Level.INFO, \"Reloaded managed bean. Bean name: \" + beanName);" +
"} "+
"LOGGER.log(Level.FINE, \"Processed dirty beans.\");" +
"}",
ctClass
);
ctClass.addMethod(processDirtyBeansMethod);
}
public static synchronized CtClass getModifiedCtClass(ClassPool classPool) throws CannotCompileException, NotFoundException {
if (MODIFIED_BEAN_MANAGER == null) {
CtClass resolverClass = classPool.get(MojarraConstants.BEAN_MANAGER_CLASS);
init(resolverClass, classPool.getClassLoader());
}
return MODIFIED_BEAN_MANAGER;
}
}
|
CtMethod getManagedBeanInfoMethod = CtMethod.make(
"public ManagedBeanInfo getManagedBeanInfo(Class beanClass) { " +
"ManagedBeanConfigHandler configHandler = new ManagedBeanConfigHandler(); " +
"Object beanInfo = " +
"ReflectionHelper.invoke(configHandler, " +
"ManagedBeanConfigHandler.class, " +
"\"getBeanInfo\", " +
"new Class[] {Class.class, ManagedBean.class}, " +
"new Object[] {beanClass, beanClass.getAnnotation(ManagedBean.class)} " +
"); " +
"LOGGER.log(Level.FINE, \"Got managed bean info. Bean Info: \" + beanInfo);" +
"return (ManagedBeanInfo)beanInfo;" +
"}",
ctClass
);
ctClass.addMethod(getManagedBeanInfoMethod);
| 1,297
| 235
| 1,532
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-mojarra-plugin/src/main/java/org/hotswap/agent/plugin/mojarra/transformer/LifecycleImplTransformer.java
|
LifecycleImplTransformer
|
init
|
class LifecycleImplTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(LifecycleImplTransformer.class);
private static Boolean isJavax;
private static boolean isJavax(ClassPool classPool) {
if (isJavax == null) {
try {
classPool.get("javax.faces.context.FacesContext");
isJavax = true;
} catch (NotFoundException e) {
isJavax = false;
}
}
return isJavax;
}
@OnClassLoadEvent(classNameRegexp = LIFECYCLE_IMPL_CLASS)
public static void init(ClassLoader classLoader, ClassPool classPool, CtClass ctClass) throws CannotCompileException, NotFoundException {<FILL_FUNCTION_BODY>}
private static void initClassPool(CtClass ctClass) throws CannotCompileException, NotFoundException {
ClassPool classPool = ctClass.getClassPool();
CtClass modifiedManagerCtClass = BeanManagerTransformer.getModifiedCtClass(classPool);
modifiedManagerCtClass.defrost();
classPool.makeClass(modifiedManagerCtClass.getClassFile());
classPool.importPackage("com.sun.faces.application");
classPool.importPackage("com.sun.faces.mgbean");
}
/**
* Patches the {@link org.apache.myfaces.lifecycle.LifecycleImpl#execute} to process dirty managed beans.
*/
private static void patchExecuteMethod(CtClass ctClass, ClassLoader classLoader) throws CannotCompileException, NotFoundException {
ClassPool classPool = ctClass.getClassPool();
CtMethod renderMethod = ctClass.getDeclaredMethod("execute", new CtClass[] {
classPool.get("javax.faces.context.FacesContext"),
});
String processDirtyBeanCall =
"ApplicationAssociate application = ApplicationAssociate.getCurrentInstance(); " +
"BeanManager beanManager = application.getBeanManager(); " +
"beanManager.processDirtyBeans(); "
;
renderMethod.insertAfter(processDirtyBeanCall);
}
}
|
if (!isJavax(classPool)) {
return; // no managed beans in jakarta
}
LOGGER.info("Patching lifecycle implementation. classLoader: {}", classLoader);
initClassPool(ctClass);
patchExecuteMethod(ctClass, classLoader);
LOGGER.info("Patched lifecycle implementation successfully.");
| 574
| 93
| 667
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-mybatis-plugin/src/main/java/org/hotswap/agent/plugin/mybatis/MyBatisPlugin.java
|
MyBatisPlugin
|
registerConfigurationFile
|
class MyBatisPlugin {
private static AgentLogger LOGGER = AgentLogger.getLogger(MyBatisPlugin.class);
@Init
Scheduler scheduler;
@Init
ClassLoader appClassLoader;
Map<String, Object> configurationMap = new HashMap<>();
Command reloadConfigurationCommand =
new ReflectionCommand(this, MyBatisRefreshCommands.class.getName(), "reloadConfiguration");
@Init
public void init(PluginConfiguration pluginConfiguration) {
LOGGER.info("MyBatis plugin initialized.");
}
public void registerConfigurationFile(String configFile, Object configObject) {<FILL_FUNCTION_BODY>}
@OnResourceFileEvent(path = "/", filter = ".*.xml", events = {FileEvent.MODIFY})
public void registerResourceListeners(URL url) throws URISyntaxException {
if (configurationMap.containsKey(Paths.get(url.toURI()).toFile().getAbsolutePath())) {
refresh(500);
}
}
// reload the configuration - schedule a command to run in the application classloader and merge
// duplicate commands.
private void refresh(int timeout) {
scheduler.scheduleCommand(reloadConfigurationCommand, timeout);
}
}
|
if (configFile != null && !configurationMap.containsKey(configFile)) {
LOGGER.debug("MyBatisPlugin - configuration file registered : {}", configFile);
configurationMap.put(configFile, configObject);
}
| 325
| 62
| 387
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-mybatis-plugin/src/main/java/org/hotswap/agent/plugin/mybatis/MyBatisRefreshCommands.java
|
MyBatisRefreshCommands
|
reloadConfiguration
|
class MyBatisRefreshCommands {
private static AgentLogger LOGGER = AgentLogger.getLogger(MyBatisRefreshCommands.class);
/**
* Flag to check reload status.
* In unit test we need to wait for reload finish before the test can continue. Set flag to true
* in the test class and wait until the flag is false again.
*/
public static boolean reloadFlag = false;
public static void reloadConfiguration() {<FILL_FUNCTION_BODY>}
}
|
LOGGER.debug("Refreshing MyBatis configuration.");
ConfigurationProxy.refreshProxiedConfigurations();
SpringMybatisConfigurationProxy.refreshProxiedConfigurations();
LOGGER.reload("MyBatis configuration refreshed.");
reloadFlag = false;
| 131
| 75
| 206
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-mybatis-plugin/src/main/java/org/hotswap/agent/plugin/mybatis/proxy/ConfigurationProxy.java
|
ConfigurationProxy
|
proxy
|
class ConfigurationProxy {
private static Map<XMLConfigBuilder, ConfigurationProxy> proxiedConfigurations = new HashMap<>();
public static ConfigurationProxy getWrapper(XMLConfigBuilder configBuilder) {
if (!proxiedConfigurations.containsKey(configBuilder)) {
proxiedConfigurations.put(configBuilder, new ConfigurationProxy(configBuilder));
}
return proxiedConfigurations.get(configBuilder);
}
public static void refreshProxiedConfigurations() {
for (ConfigurationProxy wrapper : proxiedConfigurations.values())
try {
wrapper.refreshProxiedConfiguration();
} catch (Exception e) {
e.printStackTrace();
}
}
private ConfigurationProxy(XMLConfigBuilder configBuilder) {
this.configBuilder = configBuilder;
}
public void refreshProxiedConfiguration() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
this.configuration = new Configuration();
ReflectionHelper.invoke(configBuilder, MyBatisTransformers.REFRESH_METHOD);
}
private XMLConfigBuilder configBuilder;
private Configuration configuration;
private Configuration proxyInstance;
public Configuration proxy(Configuration origConfiguration) {<FILL_FUNCTION_BODY>}
}
|
this.configuration = origConfiguration;
if (proxyInstance == null) {
ProxyFactory factory = new ProxyFactory();
factory.setSuperclass(Configuration.class);
MethodHandler handler = new MethodHandler() {
@Override
public Object invoke(Object self, Method overridden, Method forwarder,
Object[] args) throws Throwable {
return overridden.invoke(configuration, args);
}
};
try {
proxyInstance = (Configuration) factory.create(new Class[0], null, handler);
} catch (Exception e) {
throw new Error("Unable instantiate Configuration proxy", e);
}
}
return proxyInstance;
| 315
| 172
| 487
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-mybatis-plugin/src/main/java/org/hotswap/agent/plugin/mybatis/proxy/SpringMybatisConfigurationProxy.java
|
SpringMybatisConfigurationProxy
|
refreshProxiedConfiguration
|
class SpringMybatisConfigurationProxy {
private static Map<Object, SpringMybatisConfigurationProxy> proxiedConfigurations = new HashMap<>();
public SpringMybatisConfigurationProxy(Object sqlSessionFactoryBean) {
this.sqlSessionFactoryBean = sqlSessionFactoryBean;
}
public static SpringMybatisConfigurationProxy getWrapper(Object sqlSessionFactoryBean) {
if (!proxiedConfigurations.containsKey(sqlSessionFactoryBean)) {
proxiedConfigurations.put(sqlSessionFactoryBean, new SpringMybatisConfigurationProxy(sqlSessionFactoryBean));
}
return proxiedConfigurations.get(sqlSessionFactoryBean);
}
public static void refreshProxiedConfigurations() {
for (SpringMybatisConfigurationProxy wrapper : proxiedConfigurations.values())
try {
wrapper.refreshProxiedConfiguration();
} catch (Exception e) {
e.printStackTrace();
}
}
public void refreshProxiedConfiguration() {<FILL_FUNCTION_BODY>}
private Object sqlSessionFactoryBean;
private Configuration configuration;
private Configuration proxyInstance;
public Configuration proxy(Configuration origConfiguration) {
this.configuration = origConfiguration;
if (proxyInstance == null) {
ProxyFactory factory = new ProxyFactory();
factory.setSuperclass(Configuration.class);
MethodHandler handler = new MethodHandler() {
@Override
public Object invoke(Object self, Method overridden, Method forwarder,
Object[] args) throws Throwable {
return overridden.invoke(configuration, args);
}
};
try {
proxyInstance = (Configuration) factory.create(new Class[0], null, handler);
} catch (Exception e) {
throw new Error("Unable instantiate Configuration proxy", e);
}
}
return proxyInstance;
}
}
|
Object newSqlSessionFactory = ReflectionHelper.invoke(this.sqlSessionFactoryBean, "buildSqlSessionFactory");
this.configuration = (Configuration) ReflectionHelper.get(newSqlSessionFactory, "configuration");
| 476
| 53
| 529
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-mybatis-plugin/src/main/java/org/hotswap/agent/plugin/mybatis/transformers/SqlSessionFactoryBeanCaller.java
|
SqlSessionFactoryBeanCaller
|
proxyConfiguration
|
class SqlSessionFactoryBeanCaller {
public static Configuration proxyConfiguration(Object factoryBean, Configuration configuration) {<FILL_FUNCTION_BODY>}
public static void setFactoryBean(SqlSessionFactoryBuilder builder, Object factoryBean) {
ReflectionHelper.invoke(builder, SqlSessionFactoryBuilder.class,
MyBatisTransformers.FACTORYBEAN_SET_METHOD, new Class[] {Object.class}, factoryBean);
}
}
|
return (Configuration) ReflectionHelper.invoke(factoryBean, SqlSessionFactoryBean.class,
MyBatisTransformers.CONFIGURATION_PROXY_METHOD, new Class[] {Configuration.class}, configuration);
| 111
| 53
| 164
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-myfaces-plugin/src/main/java/org/hotswap/agent/plugin/myfaces/MyFacesPlugin.java
|
MyFacesPlugin
|
executeCommand
|
class MyFacesPlugin {
private static AgentLogger LOGGER = AgentLogger.getLogger(MyFacesPlugin.class);
@Init
Scheduler scheduler;
@Init
ClassLoader appClassLoader;
@Init
public void init(PluginConfiguration pluginConfiguration) {
LOGGER.info("MyFaces plugin initialized.");
}
@OnClassLoadEvent(classNameRegexp = "org.apache.myfaces.config.RuntimeConfig")
public static void facesApplicationAssociateInitialized(CtClass ctClass) throws NotFoundException, CannotCompileException {
String buildInitializePlugin = PluginManagerInvoker.buildInitializePlugin(MyFacesPlugin.class);
for (CtConstructor constructor : ctClass.getDeclaredConstructors()) {
constructor.insertAfter(buildInitializePlugin);
}
LOGGER.debug("org.apache.myfaces.config.RuntimeConfig with plugin initialization.");
}
@OnResourceFileEvent(path = "/", filter = ".*.properties")
public void refreshJsfResourceBundles() {
scheduler.scheduleCommand(refreshResourceBundles);
}
@OnClassLoadEvent(classNameRegexp = ".*", events = LoadEvent.REDEFINE)
public void reloadManagedBean(Class<?> beanClass) {
if (!AnnotationHelper.hasAnnotation(beanClass, MANAGED_BEAN_ANNOTATION)) {
return;
}
ReloadManagedBeanCommand command = new ReloadManagedBeanCommand(beanClass, appClassLoader);
scheduler.scheduleCommand(command);
}
@OnClassFileEvent(classNameRegexp = ".*", events = FileEvent.CREATE)
public void registerManagedBean(CtClass beanCtClass) throws Exception {
if (!AnnotationHelper.hasAnnotation(beanCtClass, MANAGED_BEAN_ANNOTATION)) {
return;
}
ReloadManagedBeanCommand command = new ReloadManagedBeanCommand(beanCtClass, appClassLoader);
scheduler.scheduleCommand(command);
}
private Command refreshResourceBundles = new Command() {
public void executeCommand() {<FILL_FUNCTION_BODY>}
};
private Class<?> resolveClass(String name) throws ClassNotFoundException {
return Class.forName(name, true, appClassLoader);
}
}
|
LOGGER.debug("Refreshing JSF resource bundles.");
try {
Class<?> clazz = resolveClass("java.util.ResourceBundle");
Method clearCacheMethod = clazz.getDeclaredMethod("clearCache", ClassLoader.class);
clearCacheMethod.invoke(null, appClassLoader);
} catch (Exception e) {
LOGGER.error("Error clear JSF resource bundles cache", e);
}
| 599
| 109
| 708
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-myfaces-plugin/src/main/java/org/hotswap/agent/plugin/myfaces/command/ReloadManagedBeanCommand.java
|
ReloadManagedBeanCommand
|
executeCommand
|
class ReloadManagedBeanCommand implements Command {
private static AgentLogger LOGGER = AgentLogger.getLogger(ReloadManagedBeanCommand.class);
private CtClass beanCtClass;
private Class<?> beanClass;
private ClassLoader classLoader;
public ReloadManagedBeanCommand(Class<?> beanClass, ClassLoader classLoader) {
this.beanClass = beanClass;
this.classLoader = classLoader;
}
public ReloadManagedBeanCommand(CtClass beanCtClass, ClassLoader classLoader) {
this.beanCtClass = beanCtClass;
this.classLoader = classLoader;
}
@Override
public void executeCommand() {<FILL_FUNCTION_BODY>}
private boolean isBeanClassLoadedBefore() {
return beanClass != null;
}
@SuppressWarnings("deprecation")
private Class<?> getBeanClass() throws ClassNotFoundException, CannotCompileException {
if (!isBeanClassLoadedBefore()) {
// bean is not loaded yet. try to load the class..
return beanCtClass.toClass(classLoader);
}
return beanClass;
}
private Class<?> resolveClass(String name) throws ClassNotFoundException {
return Class.forName(name, true, classLoader);
}
}
|
try {
Class<?> beanClass = getBeanClass();
if (isBeanClassLoadedBefore()) {
LOGGER.info("Reloading managed bean: {}", beanClass.getName());
} else {
LOGGER.info("Registering new managed bean: {}", beanClass.getName());
}
Class<?> beanResolverClass = resolveClass(MANAGED_BEAN_RESOLVER_CLASS);
ReflectionHelper.invoke(
null,
beanResolverClass,
"addToDirtyBeans",
new Class[] {Class.class},
new Object[] {beanClass}
);
} catch (Exception ex) {
LOGGER.info("Unable to reload managed bean. Reason: {}", ex.getMessage(), ex);
}
| 346
| 200
| 546
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-myfaces-plugin/src/main/java/org/hotswap/agent/plugin/myfaces/transformer/LifecycleImplTransformer.java
|
LifecycleImplTransformer
|
patchExecuteMethod
|
class LifecycleImplTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(LifecycleImplTransformer.class);
private static Boolean isJavax;
private static boolean isJavax(ClassPool classPool) {
if (isJavax == null) {
try {
classPool.get("javax.faces.context.FacesContext");
isJavax = true;
} catch (NotFoundException e) {
isJavax = false;
}
}
return isJavax;
}
@OnClassLoadEvent(classNameRegexp = LIFECYCLE_IMPL_CLASS)
public static void init(ClassLoader classLoader, ClassPool classPool, CtClass ctClass) throws CannotCompileException, NotFoundException {
if (!isJavax(classPool)) {
return; // no managed beans in jakarta
}
LOGGER.info("Patching lifecycle implementation. classLoader: {}", classLoader);
initClassPool(ctClass);
patchExecuteMethod(ctClass);
LOGGER.info("Patched lifecycle implementation successfully.");
}
private static void initClassPool(CtClass ctClass) throws CannotCompileException, NotFoundException {
ClassPool classPool = ctClass.getClassPool();
CtClass modifiedResolverCtClass = ManagedBeanResolverTransformer.getModifiedCtClass(classPool);
modifiedResolverCtClass.defrost();
classPool.makeClass(modifiedResolverCtClass.getClassFile());
classPool.importPackage("javax.faces.context");
classPool.importPackage("java.util");
classPool.importPackage("org.apache.myfaces.el.unified.resolver");
}
/**
* Patches the {@link org.apache.myfaces.lifecycle.LifecycleImpl#execute} to process dirty managed beans.
*/
private static void patchExecuteMethod(CtClass ctClass) throws CannotCompileException, NotFoundException {<FILL_FUNCTION_BODY>}
}
|
ClassPool classPool = ctClass.getClassPool();
CtMethod executeMethod = ctClass.getDeclaredMethod("execute", new CtClass[] {
classPool.get("javax.faces.context.FacesContext"),
});
String processDirtyBeanCall =
"ManagedBeanResolver beanResolver = new ManagedBeanResolver(); " +
"beanResolver.processDirtyBeans(); "
;
executeMethod.insertAfter(processDirtyBeanCall);
| 534
| 125
| 659
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-omnifaces-plugin/src/main/java/org/hotswap/agent/plugin/omnifaces/OmnifacesPlugin.java
|
OmnifacesPlugin
|
patchApplicationListener
|
class OmnifacesPlugin {
private static AgentLogger LOGGER = AgentLogger.getLogger(OmnifacesPlugin.class);
private boolean initialized;
public void init() {
if (!initialized) {
LOGGER.info("Omnifaces plugin initialized.");
initialized = true;
}
}
@OnClassLoadEvent(classNameRegexp = "org.omnifaces.ApplicationListener")
public static void patchApplicationListener(CtClass ctClass) throws CannotCompileException, NotFoundException {<FILL_FUNCTION_BODY>}
@OnClassLoadEvent(classNameRegexp = "org.omnifaces.cdi.viewscope.ViewScopeContext")
public static void patchViewScopeContext(ClassPool classPool, CtClass ctClass) throws CannotCompileException, NotFoundException {
HaCdiCommons.transformContext(classPool, ctClass);
}
}
|
ctClass.getDeclaredMethod("contextInitialized").insertAfter(
"{" +
PluginManagerInvoker.buildInitializePlugin(OmnifacesPlugin.class) +
PluginManagerInvoker.buildCallPluginMethod(OmnifacesPlugin.class, "init") +
"}"
);
| 232
| 80
| 312
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-jakarta-plugin/src/main/java/org/hotswap/agent/plugin/owb_jakarta/ArchivePathHelper.java
|
ArchivePathHelper
|
getNormalizedArchivePath
|
class ArchivePathHelper {
private static AgentLogger LOGGER = AgentLogger.getLogger(ArchivePathHelper.class);
public static String getNormalizedArchivePath(CtClass ctClass) throws NotFoundException {
String classFilePath = ctClass.getURL().getFile();
String className = ctClass.getName().replace(".", "/");
// archive path ends with '/' therefore we set end position before the '/' (-1)
return classFilePath.substring(0, classFilePath.indexOf(className) - 1);
}
/**
* Method resolves archive path from BdaId
*
* @param classLoader the class loader
* @param archiveId the archive id
* @return the normalized archive path
*/
public static String getNormalizedArchivePath(ClassLoader classLoader, String archiveId) {<FILL_FUNCTION_BODY>}
private static URL archivePathToURL(ClassLoader classLoader, String archiveId) {
URL result = archiveFilePathToURL(archiveId);
if (result == null) {
// File doesn't exists, try to resolve it using appClassLoader
if (classLoader instanceof URLClassLoader) {
result = archivePathToURLViaURLClassLoader((URLClassLoader) classLoader, archiveId);
}
}
return result;
}
private static URL archivePathToURLViaURLClassLoader(URLClassLoader urlClassLoader, String archivePath) {
URL[] urls = urlClassLoader.getURLs();
if (urls != null) {
for (URL url: urls) {
String fileName = url.getFile();
String checkedArchivePath = (fileName.endsWith("/") && !archivePath.endsWith("/")) ? (archivePath + "/") : archivePath;
if (fileName.endsWith(checkedArchivePath)) {
return archiveFilePathToURL(fileName);
}
}
}
return null;
}
private static URL archiveFilePathToURL(String archivePath) {
File f = new File(archivePath);
if (f.exists()) {
try {
try {
// Try to format as a URL?
return f.toURI().toURL();
} catch (MalformedURLException e) {
// try to locate a file
if (archivePath.startsWith("./"))
archivePath = archivePath.substring(2);
File file = new File(archivePath).getCanonicalFile();
return file.toURI().toURL();
}
} catch (Exception e) {
// Swallow exception
}
}
return null;
}
}
|
URL archiveURL = archivePathToURL(classLoader, archiveId);
if (archiveURL != null) {
try {
String result = archiveURL.getFile();
// Strip trailing "/" from normalized archive path
while (result.endsWith("/")) {
result = result.substring(0, result.length() -1);
}
return result;
} catch (Exception e) {
LOGGER.error("getNormalizedArchivePath() exception {}.", e.getMessage());
}
}
return null;
| 663
| 137
| 800
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-jakarta-plugin/src/main/java/org/hotswap/agent/plugin/owb_jakarta/OwbClassSignatureHelper.java
|
OwbClassSignatureHelper
|
getSignatureByStrategy
|
class OwbClassSignatureHelper {
private static AgentLogger LOGGER = AgentLogger.getLogger(OwbClassSignatureHelper.class);
private static final ClassSignatureElement[] SIGNATURE_ELEM_PROXY = {
ClassSignatureElement.SUPER_CLASS,
ClassSignatureElement.INTERFACES,
ClassSignatureElement.CLASS_ANNOTATION,
ClassSignatureElement.CONSTRUCTOR,
ClassSignatureElement.METHOD,
ClassSignatureElement.METHOD_ANNOTATION,
ClassSignatureElement.METHOD_PARAM_ANNOTATION,
ClassSignatureElement.METHOD_EXCEPTION,
ClassSignatureElement.FIELD,
ClassSignatureElement.FIELD_ANNOTATION
};
private static final ClassSignatureElement[] SIGNATURE_ELEM_METHOD_FIELDS = {
ClassSignatureElement.SUPER_CLASS,
ClassSignatureElement.INTERFACES,
ClassSignatureElement.CLASS_ANNOTATION,
ClassSignatureElement.CONSTRUCTOR,
ClassSignatureElement.CONSTRUCTOR_PRIVATE, // private constructors are used if CONSTRUCTOR && CONSTRUCTOR_PRIVATE are set
ClassSignatureElement.METHOD,
ClassSignatureElement.METHOD_PRIVATE, // private methods are used if METHOD && METHOD_PRIVATE are set
ClassSignatureElement.METHOD_ANNOTATION, // applies to constructors as well
ClassSignatureElement.METHOD_PARAM_ANNOTATION, // applies to constructors as well
ClassSignatureElement.FIELD,
ClassSignatureElement.FIELD_ANNOTATION
};
private static final ClassSignatureElement[] SIGNATURE_ELEM_FIELDS = {
ClassSignatureElement.FIELD,
ClassSignatureElement.FIELD_ANNOTATION
};
/**
* Gets the class signature for proxy class comparison
*
* @param clazz the clazz for which signature is calculated
* @return the java class signature
*/
public static String getSignatureForProxyClass(Class<?> clazz) {
try {
return ClassSignatureComparerHelper.getJavaClassSignature(clazz, SIGNATURE_ELEM_PROXY);
} catch (Exception e) {
LOGGER.error("getSignatureForProxyClass(): Error reading signature", e);
return null;
}
}
/**
* Gets the signature by strategy.
*
* @param strategy the strategy
* @param clazz the clazz
* @return the signature by strategy
*/
public static String getSignatureByStrategy(BeanReloadStrategy strategy, Class<?> clazz) {<FILL_FUNCTION_BODY>}
private static String getClassMethodFieldsSignature(Class<?> clazz) {
try {
return ClassSignatureComparerHelper.getJavaClassSignature(clazz, SIGNATURE_ELEM_METHOD_FIELDS);
} catch (Exception e) {
LOGGER.error("getSignatureForProxyClass(): Error reading signature", e);
return null;
}
}
private static String getClassFieldsSignature(Class<?> clazz) {
try {
return ClassSignatureComparerHelper.getJavaClassSignature(clazz, SIGNATURE_ELEM_FIELDS);
} catch (Exception e) {
LOGGER.error("getSignatureForProxyClass(): Error reading signature", e);
return null;
}
}
}
|
if (strategy == null) {
strategy = BeanReloadStrategy.NEVER;
}
switch (strategy) {
case CLASS_CHANGE :
return null;
case METHOD_FIELD_SIGNATURE_CHANGE :
return getClassMethodFieldsSignature(clazz);
case FIELD_SIGNATURE_CHANGE :
return getClassFieldsSignature(clazz);
default:
case NEVER:
return null;
}
| 831
| 119
| 950
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-jakarta-plugin/src/main/java/org/hotswap/agent/plugin/owb_jakarta/beans/ContextualReloadHelper.java
|
ContextualReloadHelper
|
addToReloadSet
|
class ContextualReloadHelper {
private static AgentLogger LOGGER = AgentLogger.getLogger(ContextualReloadHelper.class);
public static void reload(OwbHotswapContext ctx) {
Set<Contextual<Object>> beans = ctx.$$ha$getBeansToReloadOwb();
if (beans != null && !beans.isEmpty()) {
LOGGER.debug("Starting re-loading {} beans in context '{}'", beans.size(), ctx);
Iterator<Contextual<Object>> it = beans.iterator();
while (it.hasNext()) {
Contextual<Object> managedBean = it.next();
destroy(ctx, managedBean);
}
beans.clear();
LOGGER.debug("Finished re-loading beans in context '{}'", ctx);
}
}
/**
* Tries to add the bean in the context so it is reloaded in the next activation of the context.
*
* @param ctx
* @param managedBean
* @return
*/
@SuppressWarnings("unchecked")
public static boolean addToReloadSet(Context ctx, Contextual<?> managedBean) {<FILL_FUNCTION_BODY>}
/**
* Will remove bean from context forcing a clean new instance to be created (eg calling post-construct)
*
* @param ctx
* @param managedBean
*/
static void destroy(OwbHotswapContext ctx, Contextual<?> managedBean ) {
try {
LOGGER.debug("Removing bean '{}' from context '{}'", managedBean, ctx);
Object get = ctx.get(managedBean);
if (get != null) {
ctx.destroy(managedBean);
}
get = ctx.get(managedBean);
if (get != null) {
LOGGER.error("Error removing ManagedBean '{}', it still exists as instance '{}'", managedBean, get);
ctx.destroy(managedBean);
}
} catch (Exception e) {
LOGGER.error("Error destoying bean '{}' in context '{}'", e, managedBean, ctx);
}
}
/**
* Will re-inject any managed beans in the target. Will not call any other life-cycle methods
*
* @param ctx
* @param managedBean
*/
@SuppressWarnings("unchecked")
static void reinitialize(Context ctx, Contextual<Object> contextual) {
try {
ManagedBean<Object> managedBean = ManagedBean.class.cast(contextual);
LOGGER.debug("Re-Initializing bean '{}' in context '{}'", managedBean, ctx);
Object get = ctx.get(managedBean);
if (get != null) {
LOGGER.debug("Bean injection points are reinitialized '{}'", managedBean);
CreationalContextImpl<Object> creationalContext = managedBean.getWebBeansContext().getCreationalContextFactory().getCreationalContext(managedBean);
managedBean.getProducer().inject(get, creationalContext);
}
} catch (Exception e) {
LOGGER.error("Error reinitializing bean '{}' in context '{}'", e, contextual, ctx);
}
}
}
|
try {
LOGGER.debug("Adding bean '{}' to context '{}'", managedBean, ctx.getClass());
Field toRedefine = ctx.getClass().getField("$$ha$toReloadOwb");
Set toReload = Set.class.cast(toRedefine.get(ctx));
if (toReload == null) {
toReload = new HashSet();
toRedefine.set(ctx, toReload);
}
toReload.add(managedBean);
return true;
} catch(Exception e) {
LOGGER.warning("Context '{}' is not patched. Can not add bean '{}' to reload set", e, ctx, managedBean);
}
return false;
| 827
| 190
| 1,017
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-jakarta-plugin/src/main/java/org/hotswap/agent/plugin/owb_jakarta/command/ProxyClassLoadingDelegate.java
|
ProxyClassLoadingDelegate
|
defineAndLoadClassWithUnsafe
|
class ProxyClassLoadingDelegate {
private static AgentLogger LOGGER = AgentLogger.getLogger(ProxyClassLoadingDelegate.class);
private static final ThreadLocal<Boolean> MAGIC_IN_PROGRESS = new ThreadLocal<Boolean>() {
@Override
protected Boolean initialValue() {
return false;
}
};
private static String generatingProxyName;
public static void setGeneratingProxyName(String generatingProxyName) {
ProxyClassLoadingDelegate.generatingProxyName = generatingProxyName;
}
public static final void beginProxyRegeneration() {
MAGIC_IN_PROGRESS.set(true);
}
public static final void endProxyRegeneration() {
MAGIC_IN_PROGRESS.remove();
}
public static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException {
if (MAGIC_IN_PROGRESS.get()) {
if (generatingProxyName == null || generatingProxyName.equals(name)) {
throw new ClassNotFoundException("HotswapAgent");
}
}
return Class.forName(name, initialize, loader);
}
public static Class<?> defineAndLoadClass(AbstractProxyFactory proxyFactory, ClassLoader classLoader, String proxyName, byte[] proxyBytes) {
if (MAGIC_IN_PROGRESS.get()) {
Class<?> reloaded = reloadProxyByteCode(classLoader, proxyName, proxyBytes, null);
if (reloaded != null) {
return reloaded;
}
}
try {
return (Class<?>) ReflectionHelper.invoke(proxyFactory, AbstractProxyFactory.class, "defineAndLoadClass",
new Class[]{ClassLoader.class, String.class, byte[].class},
classLoader, proxyName, proxyBytes);
} catch (Exception e) {
LOGGER.error("defineAndLoadClass() exception {}", e.getMessage());
}
return null;
}
public static Class<?> defineAndLoadClassWithUnsafe(Object unsafe, ClassLoader classLoader, String proxyName, byte[] proxyBytes) {<FILL_FUNCTION_BODY>}
public static Class<?> defineAndLoadClassWithUnsafe(Object unsafe, ClassLoader classLoader, String proxyName, byte[] proxyBytes, Class<?> classToProxy) {
if (MAGIC_IN_PROGRESS.get()) {
Class<?> reloaded = reloadProxyByteCode(classLoader, proxyName, proxyBytes, classToProxy);
if (reloaded != null) {
return reloaded;
}
}
try {
return (Class<?>) ReflectionHelper.invoke(unsafe, unsafe.getClass(), "defineAndLoadClass",
new Class[]{ClassLoader.class, String.class, byte[].class, Class.class},
classLoader, proxyName, proxyBytes, classToProxy);
} catch (Exception e) {
LOGGER.error("defineAndLoadClass() exception {}", e.getMessage());
}
return null;
}
private static Class<?> reloadProxyByteCode(ClassLoader classLoader, String proxyName, byte[] proxyBytes, Class<?> classToProxy) {
try {
final Class<?> originalProxyClass = classLoader.loadClass(proxyName);
try {
Map<Class<?>, byte[]> reloadMap = new HashMap<>();
reloadMap.put(originalProxyClass, proxyBytes);
// TODO : is this standard way how to reload class?
PluginManager.getInstance().hotswap(reloadMap);
return originalProxyClass;
} catch (Exception e) {
throw new RuntimeException(e);
}
} catch (ClassNotFoundException e) {
//it has not actually been loaded yet
}
return null;
}
}
|
if (MAGIC_IN_PROGRESS.get()) {
Class<?> reloaded = reloadProxyByteCode(classLoader, proxyName, proxyBytes, null);
if (reloaded != null) {
return reloaded;
}
}
try {
return (Class<?>) ReflectionHelper.invoke(unsafe, unsafe.getClass(), "defineAndLoadClass",
new Class[]{ClassLoader.class, String.class, byte[].class},
classLoader, proxyName, proxyBytes);
} catch (Exception e) {
LOGGER.error("defineAndLoadClass() exception {}", e.getMessage());
}
return null;
| 967
| 169
| 1,136
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-jakarta-plugin/src/main/java/org/hotswap/agent/plugin/owb_jakarta/command/ProxyRefreshAgent.java
|
ProxyRefreshAgent
|
recreateProxy
|
class ProxyRefreshAgent {
private static AgentLogger LOGGER = AgentLogger.getLogger(ProxyRefreshAgent.class);
/**
* Recreate proxy classes, Called from BeanClassRefreshCommand.
*
* @param appClassLoader the application class loader
* @param beanClassName the bean class name
* @param oldSignatureForProxyCheck the old signature for proxy check
* @throws IOException error working with classDefinition
*/
public static synchronized void recreateProxy(ClassLoader appClassLoader, String beanClassName, String oldSignatureForProxyCheck) throws IOException {<FILL_FUNCTION_BODY>}
@SuppressWarnings("unchecked")
private static void doRecreateProxy(ClassLoader appClassLoader, Class<?> beanClass) {
ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader();
try {
ProxyClassLoadingDelegate.beginProxyRegeneration();
Thread.currentThread().setContextClassLoader(appClassLoader);
WebBeansContext wbc = WebBeansContext.currentInstance();
AnnotatedElementFactory annotatedElementFactory = wbc.getAnnotatedElementFactory();
// Clear AnnotatedElementFactory caches
annotatedElementFactory.clear();
NormalScopeProxyFactory proxyFactory = wbc.getNormalScopeProxyFactory();
InterceptorDecoratorProxyFactory interceptProxyFactory = wbc.getInterceptorDecoratorProxyFactory();
// Clear proxy class cache
Map cachedProxyClasses = (Map) ReflectionHelper.get(proxyFactory, "cachedProxyClasses");
Map interceptCachedProxyClasses = (Map) ReflectionHelper.get(interceptProxyFactory, "cachedProxyClasses");
Set<Bean<?>> beans = wbc.getBeanManagerImpl().getBeans(beanClass);
if (beans != null) {
Map<Bean, String> proxiedBeans = new LinkedHashMap<>();
Map<InjectionTargetBean, String> proxiedInterceptBeans = new LinkedHashMap<>();
for (Bean<?> bean : beans) {
if (cachedProxyClasses.containsKey(bean)) {
Class proxyClass = (Class) cachedProxyClasses.remove(bean);
proxiedBeans.put(bean, proxyClass.getName());
}
if (interceptCachedProxyClasses.containsKey(bean) && bean instanceof InjectionTargetBean) {
Class proxyClass = (Class) interceptCachedProxyClasses.remove(bean);
InjectionTargetBean injtBean = (InjectionTargetBean) bean;
if (injtBean.getProducer() instanceof AbstractProducer) {
AbstractProducer producer = (AbstractProducer) injtBean.getProducer();
// check if methodInterceptors was forwarded to new bean
proxiedInterceptBeans.put(injtBean, proxyClass.getName());
}
}
}
for (Map.Entry<Bean, String> entry : proxiedBeans.entrySet()) {
ProxyClassLoadingDelegate.setGeneratingProxyName(entry.getValue());
proxyFactory.createProxyClass(entry.getKey(), appClassLoader, beanClass);
}
for (Map.Entry<InjectionTargetBean, String> entry : proxiedInterceptBeans.entrySet()) {
ProxyClassLoadingDelegate.setGeneratingProxyName(entry.getValue());
recreateInterceptedProxy(appClassLoader, entry.getKey(), wbc);
}
}
} catch (Exception e) {
LOGGER.error("Proxy redefinition failed {}.", e, e.getMessage());
} finally {
Thread.currentThread().setContextClassLoader(oldContextClassLoader);
ProxyClassLoadingDelegate.endProxyRegeneration();
ProxyClassLoadingDelegate.setGeneratingProxyName(null);
}
}
private static void recreateInterceptedProxy(ClassLoader appClassLoader, Bean bean, WebBeansContext wbc) {
if (!(bean instanceof OwbBean) || bean instanceof Interceptor || bean instanceof Decorator) {
return;
}
OwbBean owbBean = (OwbBean) bean;
AbstractProducer producer = (AbstractProducer) owbBean.getProducer();
AnnotatedType annotatedType = ((InjectionTargetBean) owbBean).getAnnotatedType();
producer.defineInterceptorStack(bean, annotatedType, wbc);
}
}
|
try {
Class<?> beanClass = appClassLoader.loadClass(beanClassName);
if (oldSignatureForProxyCheck != null) {
String newClassSignature = OwbClassSignatureHelper.getSignatureForProxyClass(beanClass);
if (newClassSignature != null && !newClassSignature.equals(oldSignatureForProxyCheck)) {
doRecreateProxy(appClassLoader, beanClass);
}
}
} catch (ClassNotFoundException e) {
LOGGER.error("Bean class '{}' not found.", beanClassName, e);
}
| 1,095
| 144
| 1,239
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-jakarta-plugin/src/main/java/org/hotswap/agent/plugin/owb_jakarta/transformer/AbstractProducerTransformer.java
|
AbstractProducerTransformer
|
patchProxyFactory
|
class AbstractProducerTransformer {
@OnClassLoadEvent(classNameRegexp = "org.apache.webbeans.portable.AbstractProducer")
public static void patchProxyFactory(CtClass ctClass, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
if (!HaCdiCommons.isJakarta(classPool)) {
return;
}
CtMethod getProxyClassMethod = ctClass.getDeclaredMethod("defineInterceptorStack");
getProxyClassMethod.instrument(
new ExprEditor() {
public void edit(FieldAccess e) throws CannotCompileException {
if (e.isWriter() && "methodInterceptors".equals(e.getFieldName())) {
e.replace("{ " +
"if($0.methodInterceptors==null) $0.methodInterceptors=new java.util.HashMap();" +
"$0.methodInterceptors.clear();" +
"$0.methodInterceptors.putAll($1);" +
"}");
}
}
});
| 83
| 204
| 287
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-jakarta-plugin/src/main/java/org/hotswap/agent/plugin/owb_jakarta/transformer/BeansDeployerTransformer.java
|
BeansDeployerTransformer
|
transform
|
class BeansDeployerTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(BeansDeployerTransformer.class);
/**
* Basic CdiArchive transformation.
*
* @param clazz
* @param classPool
* @throws NotFoundException
* @throws CannotCompileException
*/
@OnClassLoadEvent(classNameRegexp = "org.apache.webbeans.config.BeansDeployer")
public static void transform(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
if (!HaCdiCommons.isJakarta(classPool)) {
return;
}
StringBuilder src = new StringBuilder(" if (deployed) {");
src.append("ClassLoader curCl = Thread.currentThread().getContextClassLoader();");
src.append(PluginManagerInvoker.buildInitializePlugin(OwbJakartaPlugin.class, "curCl"));
src.append(PluginManagerInvoker.buildCallPluginMethod("curCl", OwbJakartaPlugin.class, "init"));
src.append(PluginManagerInvoker.buildCallPluginMethod("curCl", OwbJakartaPlugin.class, "registerBeansXmls", "$1.getBeanXmls()", "java.util.Set"));
src.append("}");
CtMethod startApplication = clazz.getDeclaredMethod("deploy");
startApplication.insertAfter(src.toString());
LOGGER.debug("Class '{}' patched with OwbPlugin registration.", clazz.getName());
| 159
| 254
| 413
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-jakarta-plugin/src/main/java/org/hotswap/agent/plugin/owb_jakarta/transformer/CdiContextsTransformer.java
|
CdiContextsTransformer
|
transformOwbContexts
|
class CdiContextsTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(CdiContextsTransformer.class);
@OnClassLoadEvent(classNameRegexp = "(org.apache.webbeans.context.AbstractContext)|" +
"(org.apache.myfaces.flow.cdi.FlowScopedContextImpl)|" +
"(org.apache.myfaces.cdi.view.ViewScopeContextImpl)")
public static void transformOwbContexts(CtClass clazz, ClassPool classPool, ClassLoader cl) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
/*
static void addDestroyMethod(CtClass clazz, ClassPool classPool) {
CtMethod destroy = null;
try {
destroy = clazz.getDeclaredMethod("destroy", new CtClass[] {classPool.get("jakarta.enterprise.context.spi.Contextual")});
} catch (NotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(destroy == null) {
try {
clazz.addMethod(CtMethod.make(//
"public void destroy(jakarta.enterprise.context.spi.Contextual c) {\n"+//
ContextualReloadHelper.class.getName() +".reinitialize(this, c);\n"+
"}\n", clazz));
} catch (CannotCompileException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
*/
@OnClassLoadEvent(classNameRegexp = "org.apache.webbeans.context.AbstractContext")
public static void transformAbstractContext(ClassPool classPool, CtClass ctClass) throws NotFoundException, CannotCompileException {
if (!HaCdiCommons.isJakarta(classPool)) {
return;
}
HaCdiCommons.transformContext(classPool, ctClass);
}
}
|
if (!HaCdiCommons.isJakarta(classPool)) {
return;
}
CtClass superClass = clazz.getSuperclass();
while (superClass != null) {
if ("org.apache.webbeans.context.AbstractContext".equals(superClass.getName())) {
return;
}
superClass = superClass.getSuperclass();
}
LOGGER.debug("Adding interface {} to {}.", OwbHotswapContext.class.getName(), clazz.getName());
clazz.addInterface(classPool.get(OwbHotswapContext.class.getName()));
CtField toReloadFld = CtField.make("public transient java.util.Set $$ha$toReloadOwb = null;", clazz);
clazz.addField(toReloadFld);
CtField reloadingFld = CtField.make("public transient boolean $$ha$reloadingOwb = false;", clazz);
clazz.addField(reloadingFld);
CtMethod addBeanToReload = CtMethod.make(
"public void $$ha$addBeanToReloadOwb(jakarta.enterprise.context.spi.Contextual bean){" +
"if ($$ha$toReloadOwb == null)" +
"$$ha$toReloadOwb = new java.util.HashSet();" +
"$$ha$toReloadOwb.add(bean);" +
"}",
clazz
);
clazz.addMethod(addBeanToReload);
CtMethod getBeansToReload = CtMethod.make("public java.util.Set $$ha$getBeansToReloadOwb(){return $$ha$toReloadOwb;}", clazz);
clazz.addMethod(getBeansToReload);
CtMethod reload = CtMethod.make("public void $$ha$reloadOwb() {" + ContextualReloadHelper.class.getName() +".reload(this);}", clazz);
clazz.addMethod(reload);
CtMethod isActive = clazz.getDeclaredMethod("isActive");
isActive.insertAfter(
"if($_ && !$$ha$reloadingOwb ) { " +
"$$ha$reloadingOwb = true;" +
"$$ha$reloadOwb();" +
"$$ha$reloadingOwb = false;" +
"}" +
"return $_;"
);
//addDestroyMethod(clazz, classPool);
LOGGER.debug("Class '{}' patched with hot-swapping support", clazz.getName() );
| 514
| 683
| 1,197
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-jakarta-plugin/src/main/java/org/hotswap/agent/plugin/owb_jakarta/transformer/ProxyFactoryTransformer.java
|
ProxyFactoryTransformer
|
patchProxyFactory
|
class ProxyFactoryTransformer {
/**
* Patch AbstractProxyFactory class.
* - add factory registration into constructor
* - changes call classLoader.loadClass(...) in getProxyClass() to ProxyClassLoadingDelegate.loadClass(classLoader, ...)
* - changes call ClassFileUtils.toClass() in createProxyClass() to ProxyClassLoadingDelegate.loadClass(...)
*
* @param ctClass the ProxyFactory class
* @param classPool the class pool
* @throws NotFoundException the not found exception
* @throws CannotCompileException the cannot compile exception
*/
@OnClassLoadEvent(classNameRegexp = "org.apache.webbeans.proxy.AbstractProxyFactory")
public static void patchProxyFactory(CtClass ctClass, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
if (!HaCdiCommons.isJakarta(classPool)) {
return;
}
CtMethod getProxyClassMethod = ctClass.getDeclaredMethod("getUnusedProxyClassName");
getProxyClassMethod.instrument(
new ExprEditor() {
public void edit(MethodCall m) throws CannotCompileException {
if (m.getClassName().equals(Class.class.getName()) && m.getMethodName().equals("forName"))
m.replace("{ $_ = org.hotswap.agent.plugin.owb_jakarta.command.ProxyClassLoadingDelegate.forName($$); }");
}
});
CtMethod createProxyClassMethod = ctClass.getDeclaredMethod("createProxyClass", new CtClass[] {
classPool.get(ClassLoader.class.getName()),
classPool.get(String.class.getName()),
classPool.get(Class.class.getName()),
classPool.get(Method.class.getName() + "[]"),
classPool.get(Method.class.getName() + "[]"),
classPool.get(Constructor.class.getName())
}
);
createProxyClassMethod.instrument(
new ExprEditor() {
public void edit(MethodCall m) throws CannotCompileException {
if (m.getMethodName().equals("defineAndLoadClass"))
if ("org.apache.webbeans.proxy.Unsafe".equals(m.getClassName())) {
// OWB >= 2.0.8
m.replace("{ $_ = org.hotswap.agent.plugin.owb_jakarta.command.ProxyClassLoadingDelegate.defineAndLoadClassWithUnsafe(this.unsafe, $$); }");
} else {
// OWB < 2.0.8
m.replace("{ $_ = org.hotswap.agent.plugin.owb_jakarta.command.ProxyClassLoadingDelegate.defineAndLoadClass(this, $$); }");
}
}
});
| 223
| 507
| 730
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-plugin/src/main/java/org/hotswap/agent/plugin/owb/ArchivePathHelper.java
|
ArchivePathHelper
|
getNormalizedArchivePath
|
class ArchivePathHelper {
private static AgentLogger LOGGER = AgentLogger.getLogger(ArchivePathHelper.class);
public static String getNormalizedArchivePath(CtClass ctClass) throws NotFoundException {
String classFilePath = ctClass.getURL().getFile();
String className = ctClass.getName().replace(".", "/");
// archive path ends with '/' therefore we set end position before the '/' (-1)
return classFilePath.substring(0, classFilePath.indexOf(className) - 1);
}
/**
* Method resolves archive path from BdaId
*
* @param classLoader the class loader
* @param archiveId the archive id
* @return the normalized archive path
*/
public static String getNormalizedArchivePath(ClassLoader classLoader, String archiveId) {<FILL_FUNCTION_BODY>}
private static URL archivePathToURL(ClassLoader classLoader, String archiveId) {
URL result = archiveFilePathToURL(archiveId);
if (result == null) {
// File doesn't exists, try to resolve it using appClassLoader
if (classLoader instanceof URLClassLoader) {
result = archivePathToURLViaURLClassLoader((URLClassLoader) classLoader, archiveId);
}
}
return result;
}
private static URL archivePathToURLViaURLClassLoader(URLClassLoader urlClassLoader, String archivePath) {
URL[] urls = urlClassLoader.getURLs();
if (urls != null) {
for (URL url: urls) {
String fileName = url.getFile();
String checkedArchivePath = (fileName.endsWith("/") && !archivePath.endsWith("/")) ? (archivePath + "/") : archivePath;
if (fileName.endsWith(checkedArchivePath)) {
return archiveFilePathToURL(fileName);
}
}
}
return null;
}
private static URL archiveFilePathToURL(String archivePath) {
File f = new File(archivePath);
if (f.exists()) {
try {
try {
// Try to format as a URL?
return f.toURI().toURL();
} catch (MalformedURLException e) {
// try to locate a file
if (archivePath.startsWith("./"))
archivePath = archivePath.substring(2);
File file = new File(archivePath).getCanonicalFile();
return file.toURI().toURL();
}
} catch (Exception e) {
// Swallow exception
}
}
return null;
}
}
|
URL archiveURL = archivePathToURL(classLoader, archiveId);
if (archiveURL != null) {
try {
String result = archiveURL.getFile();
// Strip trailing "/" from normalized archive path
while (result.endsWith("/")) {
result = result.substring(0, result.length() -1);
}
return result;
} catch (Exception e) {
LOGGER.error("getNormalizedArchivePath() exception {}.", e.getMessage());
}
}
return null;
| 663
| 137
| 800
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-plugin/src/main/java/org/hotswap/agent/plugin/owb/OwbClassSignatureHelper.java
|
OwbClassSignatureHelper
|
getSignatureForProxyClass
|
class OwbClassSignatureHelper {
private static AgentLogger LOGGER = AgentLogger.getLogger(OwbClassSignatureHelper.class);
private static final ClassSignatureElement[] SIGNATURE_ELEM_PROXY = {
ClassSignatureElement.SUPER_CLASS,
ClassSignatureElement.INTERFACES,
ClassSignatureElement.CLASS_ANNOTATION,
ClassSignatureElement.CONSTRUCTOR,
ClassSignatureElement.METHOD,
ClassSignatureElement.METHOD_ANNOTATION,
ClassSignatureElement.METHOD_PARAM_ANNOTATION,
ClassSignatureElement.METHOD_EXCEPTION,
ClassSignatureElement.FIELD,
ClassSignatureElement.FIELD_ANNOTATION
};
private static final ClassSignatureElement[] SIGNATURE_ELEM_METHOD_FIELDS = {
ClassSignatureElement.SUPER_CLASS,
ClassSignatureElement.INTERFACES,
ClassSignatureElement.CLASS_ANNOTATION,
ClassSignatureElement.CONSTRUCTOR,
ClassSignatureElement.CONSTRUCTOR_PRIVATE, // private constructors are used if CONSTRUCTOR && CONSTRUCTOR_PRIVATE are set
ClassSignatureElement.METHOD,
ClassSignatureElement.METHOD_PRIVATE, // private methods are used if METHOD && METHOD_PRIVATE are set
ClassSignatureElement.METHOD_ANNOTATION, // applies to constructors as well
ClassSignatureElement.METHOD_PARAM_ANNOTATION, // applies to constructors as well
ClassSignatureElement.FIELD,
ClassSignatureElement.FIELD_ANNOTATION
};
private static final ClassSignatureElement[] SIGNATURE_ELEM_FIELDS = {
ClassSignatureElement.FIELD,
ClassSignatureElement.FIELD_ANNOTATION
};
/**
* Gets the class signature for proxy class comparison
*
* @param clazz the clazz for which signature is calculated
* @return the java class signature
*/
public static String getSignatureForProxyClass(Class<?> clazz) {<FILL_FUNCTION_BODY>}
/**
* Gets the signature by strategy.
*
* @param strategy the strategy
* @param clazz the clazz
* @return the signature by strategy
*/
public static String getSignatureByStrategy(BeanReloadStrategy strategy, Class<?> clazz) {
if (strategy == null) {
strategy = BeanReloadStrategy.NEVER;
}
switch (strategy) {
case CLASS_CHANGE :
return null;
case METHOD_FIELD_SIGNATURE_CHANGE :
return getClassMethodFieldsSignature(clazz);
case FIELD_SIGNATURE_CHANGE :
return getClassFieldsSignature(clazz);
default:
case NEVER:
return null;
}
}
private static String getClassMethodFieldsSignature(Class<?> clazz) {
try {
return ClassSignatureComparerHelper.getJavaClassSignature(clazz, SIGNATURE_ELEM_METHOD_FIELDS);
} catch (Exception e) {
LOGGER.error("getSignatureForProxyClass(): Error reading signature", e);
return null;
}
}
private static String getClassFieldsSignature(Class<?> clazz) {
try {
return ClassSignatureComparerHelper.getJavaClassSignature(clazz, SIGNATURE_ELEM_FIELDS);
} catch (Exception e) {
LOGGER.error("getSignatureForProxyClass(): Error reading signature", e);
return null;
}
}
}
|
try {
return ClassSignatureComparerHelper.getJavaClassSignature(clazz, SIGNATURE_ELEM_PROXY);
} catch (Exception e) {
LOGGER.error("getSignatureForProxyClass(): Error reading signature", e);
return null;
}
| 879
| 71
| 950
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-plugin/src/main/java/org/hotswap/agent/plugin/owb/beans/ContextualReloadHelper.java
|
ContextualReloadHelper
|
addToReloadSet
|
class ContextualReloadHelper {
private static AgentLogger LOGGER = AgentLogger.getLogger(ContextualReloadHelper.class);
public static void reload(OwbHotswapContext ctx) {
Set<Contextual<Object>> beans = ctx.$$ha$getBeansToReloadOwb();
if (beans != null && !beans.isEmpty()) {
LOGGER.debug("Starting re-loading {} beans in context '{}'", beans.size(), ctx);
Iterator<Contextual<Object>> it = beans.iterator();
while (it.hasNext()) {
Contextual<Object> managedBean = it.next();
destroy(ctx, managedBean);
}
beans.clear();
LOGGER.debug("Finished re-loading beans in context '{}'", ctx);
}
}
/**
* Tries to add the bean in the context so it is reloaded in the next activation of the context.
*
* @param ctx
* @param managedBean
* @return
*/
@SuppressWarnings("unchecked")
public static boolean addToReloadSet(Context ctx, Contextual<?> managedBean) {<FILL_FUNCTION_BODY>}
/**
* Will remove bean from context forcing a clean new instance to be created (eg calling post-construct)
*
* @param ctx
* @param managedBean
*/
static void destroy(OwbHotswapContext ctx, Contextual<?> managedBean ) {
try {
LOGGER.debug("Removing bean '{}' from context '{}'", managedBean, ctx);
Object get = ctx.get(managedBean);
if (get != null) {
ctx.destroy(managedBean);
}
get = ctx.get(managedBean);
if (get != null) {
LOGGER.error("Error removing ManagedBean '{}', it still exists as instance '{}'", managedBean, get);
ctx.destroy(managedBean);
}
} catch (Exception e) {
LOGGER.error("Error destoying bean '{}' in context '{}'", e, managedBean, ctx);
}
}
/**
* Will re-inject any managed beans in the target. Will not call any other life-cycle methods
*
* @param ctx
* @param managedBean
*/
@SuppressWarnings("unchecked")
static void reinitialize(Context ctx, Contextual<Object> contextual) {
try {
ManagedBean<Object> managedBean = ManagedBean.class.cast(contextual);
LOGGER.debug("Re-Initializing bean '{}' in context '{}'", managedBean, ctx);
Object get = ctx.get(managedBean);
if (get != null) {
LOGGER.debug("Bean injection points are reinitialized '{}'", managedBean);
CreationalContextImpl<Object> creationalContext = managedBean.getWebBeansContext().getCreationalContextFactory().getCreationalContext(managedBean);
managedBean.getProducer().inject(get, creationalContext);
}
} catch (Exception e) {
LOGGER.error("Error reinitializing bean '{}' in context '{}'", e, contextual, ctx);
}
}
}
|
try {
LOGGER.debug("Adding bean '{}' to context '{}'", managedBean, ctx.getClass());
Field toRedefine = ctx.getClass().getField("$$ha$toReloadOwb");
Set toReload = Set.class.cast(toRedefine.get(ctx));
if (toReload == null) {
toReload = new HashSet();
toRedefine.set(ctx, toReload);
}
toReload.add(managedBean);
return true;
} catch(Exception e) {
LOGGER.warning("Context '{}' is not patched. Can not add bean '{}' to reload set", e, ctx, managedBean);
}
return false;
| 827
| 190
| 1,017
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-plugin/src/main/java/org/hotswap/agent/plugin/owb/command/ProxyClassLoadingDelegate.java
|
ProxyClassLoadingDelegate
|
defineAndLoadClassWithUnsafe
|
class ProxyClassLoadingDelegate {
private static AgentLogger LOGGER = AgentLogger.getLogger(ProxyClassLoadingDelegate.class);
private static final ThreadLocal<Boolean> MAGIC_IN_PROGRESS = new ThreadLocal<Boolean>() {
@Override
protected Boolean initialValue() {
return false;
}
};
private static String generatingProxyName;
public static void setGeneratingProxyName(String generatingProxyName) {
ProxyClassLoadingDelegate.generatingProxyName = generatingProxyName;
}
public static final void beginProxyRegeneration() {
MAGIC_IN_PROGRESS.set(true);
}
public static final void endProxyRegeneration() {
MAGIC_IN_PROGRESS.remove();
}
public static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException {
if (MAGIC_IN_PROGRESS.get()) {
if (generatingProxyName == null || generatingProxyName.equals(name)) {
throw new ClassNotFoundException("HotswapAgent");
}
}
return Class.forName(name, initialize, loader);
}
public static Class<?> defineAndLoadClass(AbstractProxyFactory proxyFactory, ClassLoader classLoader, String proxyName, byte[] proxyBytes) {
if (MAGIC_IN_PROGRESS.get()) {
Class<?> reloaded = reloadProxyByteCode(classLoader, proxyName, proxyBytes, null);
if (reloaded != null) {
return reloaded;
}
}
try {
return (Class<?>) ReflectionHelper.invoke(proxyFactory, AbstractProxyFactory.class, "defineAndLoadClass",
new Class[]{ClassLoader.class, String.class, byte[].class},
classLoader, proxyName, proxyBytes);
} catch (Exception e) {
LOGGER.error("defineAndLoadClass() exception {}", e.getMessage());
}
return null;
}
public static Class<?> defineAndLoadClassWithUnsafe(Object unsafe, ClassLoader classLoader, String proxyName, byte[] proxyBytes) {
if (MAGIC_IN_PROGRESS.get()) {
Class<?> reloaded = reloadProxyByteCode(classLoader, proxyName, proxyBytes, null);
if (reloaded != null) {
return reloaded;
}
}
try {
return (Class<?>) ReflectionHelper.invoke(unsafe, unsafe.getClass(), "defineAndLoadClass",
new Class[]{ClassLoader.class, String.class, byte[].class},
classLoader, proxyName, proxyBytes);
} catch (Exception e) {
LOGGER.error("defineAndLoadClass() exception {}", e.getMessage());
}
return null;
}
public static Class<?> defineAndLoadClassWithUnsafe(Object unsafe, ClassLoader classLoader, String proxyName, byte[] proxyBytes, Class<?> classToProxy) {<FILL_FUNCTION_BODY>}
private static Class<?> reloadProxyByteCode(ClassLoader classLoader, String proxyName, byte[] proxyBytes, Class<?> classToProxy) {
try {
final Class<?> originalProxyClass = classLoader.loadClass(proxyName);
try {
Map<Class<?>, byte[]> reloadMap = new HashMap<>();
reloadMap.put(originalProxyClass, proxyBytes);
// TODO : is this standard way how to reload class?
PluginManager.getInstance().hotswap(reloadMap);
return originalProxyClass;
} catch (Exception e) {
throw new RuntimeException(e);
}
} catch (ClassNotFoundException e) {
//it has not actually been loaded yet
}
return null;
}
}
|
if (MAGIC_IN_PROGRESS.get()) {
Class<?> reloaded = reloadProxyByteCode(classLoader, proxyName, proxyBytes, classToProxy);
if (reloaded != null) {
return reloaded;
}
}
try {
return (Class<?>) ReflectionHelper.invoke(unsafe, unsafe.getClass(), "defineAndLoadClass",
new Class[]{ClassLoader.class, String.class, byte[].class, Class.class},
classLoader, proxyName, proxyBytes, classToProxy);
} catch (Exception e) {
LOGGER.error("defineAndLoadClass() exception {}", e.getMessage());
}
return null;
| 957
| 179
| 1,136
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-plugin/src/main/java/org/hotswap/agent/plugin/owb/command/ProxyRefreshAgent.java
|
ProxyRefreshAgent
|
doRecreateProxy
|
class ProxyRefreshAgent {
private static AgentLogger LOGGER = AgentLogger.getLogger(ProxyRefreshAgent.class);
/**
* Recreate proxy classes, Called from BeanClassRefreshCommand.
*
* @param appClassLoader the application class loader
* @param beanClassName the bean class name
* @param oldSignatureForProxyCheck the old signature for proxy check
* @throws IOException error working with classDefinition
*/
public static synchronized void recreateProxy(ClassLoader appClassLoader, String beanClassName, String oldSignatureForProxyCheck) throws IOException {
try {
Class<?> beanClass = appClassLoader.loadClass(beanClassName);
if (oldSignatureForProxyCheck != null) {
String newClassSignature = OwbClassSignatureHelper.getSignatureForProxyClass(beanClass);
if (newClassSignature != null && !newClassSignature.equals(oldSignatureForProxyCheck)) {
doRecreateProxy(appClassLoader, beanClass);
}
}
} catch (ClassNotFoundException e) {
LOGGER.error("Bean class '{}' not found.", beanClassName, e);
}
}
@SuppressWarnings("unchecked")
private static void doRecreateProxy(ClassLoader appClassLoader, Class<?> beanClass) {<FILL_FUNCTION_BODY>}
private static void recreateInterceptedProxy(ClassLoader appClassLoader, Bean bean, WebBeansContext wbc) {
if (!(bean instanceof OwbBean) || bean instanceof Interceptor || bean instanceof Decorator) {
return;
}
OwbBean owbBean = (OwbBean) bean;
AbstractProducer producer = (AbstractProducer) owbBean.getProducer();
AnnotatedType annotatedType = ((InjectionTargetBean) owbBean).getAnnotatedType();
producer.defineInterceptorStack(bean, annotatedType, wbc);
}
}
|
ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader();
try {
ProxyClassLoadingDelegate.beginProxyRegeneration();
Thread.currentThread().setContextClassLoader(appClassLoader);
WebBeansContext wbc = WebBeansContext.currentInstance();
AnnotatedElementFactory annotatedElementFactory = wbc.getAnnotatedElementFactory();
// Clear AnnotatedElementFactory caches
annotatedElementFactory.clear();
NormalScopeProxyFactory proxyFactory = wbc.getNormalScopeProxyFactory();
InterceptorDecoratorProxyFactory interceptProxyFactory = wbc.getInterceptorDecoratorProxyFactory();
// Clear proxy class cache
Map cachedProxyClasses = (Map) ReflectionHelper.get(proxyFactory, "cachedProxyClasses");
Map interceptCachedProxyClasses = (Map) ReflectionHelper.get(interceptProxyFactory, "cachedProxyClasses");
Set<Bean<?>> beans = wbc.getBeanManagerImpl().getBeans(beanClass);
if (beans != null) {
Map<Bean, String> proxiedBeans = new LinkedHashMap<>();
Map<InjectionTargetBean, String> proxiedInterceptBeans = new LinkedHashMap<>();
for (Bean<?> bean : beans) {
if (cachedProxyClasses.containsKey(bean)) {
Class proxyClass = (Class) cachedProxyClasses.remove(bean);
proxiedBeans.put(bean, proxyClass.getName());
}
if (interceptCachedProxyClasses.containsKey(bean) && bean instanceof InjectionTargetBean) {
Class proxyClass = (Class) interceptCachedProxyClasses.remove(bean);
InjectionTargetBean injtBean = (InjectionTargetBean) bean;
if (injtBean.getProducer() instanceof AbstractProducer) {
AbstractProducer producer = (AbstractProducer) injtBean.getProducer();
// check if methodInterceptors was forwarded to new bean
proxiedInterceptBeans.put(injtBean, proxyClass.getName());
}
}
}
for (Map.Entry<Bean, String> entry : proxiedBeans.entrySet()) {
ProxyClassLoadingDelegate.setGeneratingProxyName(entry.getValue());
proxyFactory.createProxyClass(entry.getKey(), appClassLoader, beanClass);
}
for (Map.Entry<InjectionTargetBean, String> entry : proxiedInterceptBeans.entrySet()) {
ProxyClassLoadingDelegate.setGeneratingProxyName(entry.getValue());
recreateInterceptedProxy(appClassLoader, entry.getKey(), wbc);
}
}
} catch (Exception e) {
LOGGER.error("Proxy redefinition failed {}.", e, e.getMessage());
} finally {
Thread.currentThread().setContextClassLoader(oldContextClassLoader);
ProxyClassLoadingDelegate.endProxyRegeneration();
ProxyClassLoadingDelegate.setGeneratingProxyName(null);
}
| 490
| 749
| 1,239
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-plugin/src/main/java/org/hotswap/agent/plugin/owb/transformer/AbstractProducerTransformer.java
|
AbstractProducerTransformer
|
edit
|
class AbstractProducerTransformer {
@OnClassLoadEvent(classNameRegexp = "org.apache.webbeans.portable.AbstractProducer")
public static void patchProxyFactory(CtClass ctClass, ClassPool classPool) throws NotFoundException, CannotCompileException {
if (HaCdiCommons.isJakarta(classPool)) {
return;
}
CtMethod getProxyClassMethod = ctClass.getDeclaredMethod("defineInterceptorStack");
getProxyClassMethod.instrument(
new ExprEditor() {
public void edit(FieldAccess e) throws CannotCompileException {<FILL_FUNCTION_BODY>}
});
}
}
|
if (e.isWriter() && "methodInterceptors".equals(e.getFieldName())) {
e.replace("{ " +
"if($0.methodInterceptors==null) $0.methodInterceptors=new java.util.HashMap();" +
"$0.methodInterceptors.clear();" +
"$0.methodInterceptors.putAll($1);" +
"}");
}
| 175
| 112
| 287
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-plugin/src/main/java/org/hotswap/agent/plugin/owb/transformer/BeansDeployerTransformer.java
|
BeansDeployerTransformer
|
transform
|
class BeansDeployerTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(BeansDeployerTransformer.class);
/**
* Basic CdiArchive transformation.
*
* @param clazz
* @param classPool
* @throws NotFoundException
* @throws CannotCompileException
*/
@OnClassLoadEvent(classNameRegexp = "org.apache.webbeans.config.BeansDeployer")
public static void transform(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
if (HaCdiCommons.isJakarta(classPool)) {
return;
}
StringBuilder src = new StringBuilder(" if (deployed) {");
src.append("ClassLoader curCl = Thread.currentThread().getContextClassLoader();");
src.append(PluginManagerInvoker.buildInitializePlugin(OwbPlugin.class, "curCl"));
src.append(PluginManagerInvoker.buildCallPluginMethod("curCl", OwbPlugin.class, "init"));
src.append(PluginManagerInvoker.buildCallPluginMethod("curCl", OwbPlugin.class, "registerBeansXmls", "$1.getBeanXmls()", "java.util.Set"));
src.append("}");
CtMethod startApplication = clazz.getDeclaredMethod("deploy");
startApplication.insertAfter(src.toString());
LOGGER.debug("Class '{}' patched with OwbPlugin registration.", clazz.getName());
| 159
| 242
| 401
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-plugin/src/main/java/org/hotswap/agent/plugin/owb/transformer/CdiContextsTransformer.java
|
CdiContextsTransformer
|
transformOwbContexts
|
class CdiContextsTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(CdiContextsTransformer.class);
@OnClassLoadEvent(classNameRegexp = "(org.apache.webbeans.context.AbstractContext)|" +
"(org.apache.myfaces.flow.cdi.FlowScopedContextImpl)|" +
"(org.apache.myfaces.cdi.view.ViewScopeContextImpl)")
public static void transformOwbContexts(CtClass clazz, ClassPool classPool, ClassLoader cl) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
/*
static void addDestroyMethod(CtClass clazz, ClassPool classPool) {
CtMethod destroy = null;
try {
destroy = clazz.getDeclaredMethod("destroy", new CtClass[] {classPool.get("javax.enterprise.context.spi.Contextual")});
} catch (NotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(destroy == null) {
try {
clazz.addMethod(CtMethod.make(//
"public void destroy(javax.enterprise.context.spi.Contextual c) {\n"+//
ContextualReloadHelper.class.getName() +".reinitialize(this, c);\n"+
"}\n", clazz));
} catch (CannotCompileException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
*/
@OnClassLoadEvent(classNameRegexp = "org.apache.webbeans.context.AbstractContext")
public static void transformAbstractContext(ClassPool classPool, CtClass ctClass) throws NotFoundException, CannotCompileException {
if (HaCdiCommons.isJakarta(classPool)) {
return;
}
HaCdiCommons.transformContext(classPool, ctClass);
}
}
|
if (HaCdiCommons.isJakarta(classPool)) {
return;
}
CtClass superClass = clazz.getSuperclass();
while (superClass != null) {
if ("org.apache.webbeans.context.AbstractContext".equals(superClass.getName())) {
return;
}
superClass = superClass.getSuperclass();
}
LOGGER.debug("Adding interface {} to {}.", OwbHotswapContext.class.getName(), clazz.getName());
clazz.addInterface(classPool.get(OwbHotswapContext.class.getName()));
CtField toReloadFld = CtField.make("public transient java.util.Set $$ha$toReloadOwb = null;", clazz);
clazz.addField(toReloadFld);
CtField reloadingFld = CtField.make("public transient boolean $$ha$reloadingOwb = false;", clazz);
clazz.addField(reloadingFld);
CtMethod addBeanToReload = CtMethod.make(
"public void $$ha$addBeanToReloadOwb(javax.enterprise.context.spi.Contextual bean){" +
"if ($$ha$toReloadOwb == null)" +
"$$ha$toReloadOwb = new java.util.HashSet();" +
"$$ha$toReloadOwb.add(bean);" +
"}",
clazz
);
clazz.addMethod(addBeanToReload);
CtMethod getBeansToReload = CtMethod.make("public java.util.Set $$ha$getBeansToReloadOwb(){return $$ha$toReloadOwb;}", clazz);
clazz.addMethod(getBeansToReload);
CtMethod reload = CtMethod.make("public void $$ha$reloadOwb() {" + ContextualReloadHelper.class.getName() +".reload(this);}", clazz);
clazz.addMethod(reload);
CtMethod isActive = clazz.getDeclaredMethod("isActive");
isActive.insertAfter(
"if($_ && !$$ha$reloadingOwb ) { " +
"$$ha$reloadingOwb = true;" +
"$$ha$reloadOwb();" +
"$$ha$reloadingOwb = false;" +
"}" +
"return $_;"
);
//addDestroyMethod(clazz, classPool);
LOGGER.debug("Class '{}' patched with hot-swapping support", clazz.getName() );
| 510
| 681
| 1,191
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-owb-plugin/src/main/java/org/hotswap/agent/plugin/owb/transformer/ProxyFactoryTransformer.java
|
ProxyFactoryTransformer
|
patchProxyFactory
|
class ProxyFactoryTransformer {
/**
* Patch AbstractProxyFactory class.
* - add factory registration into constructor
* - changes call classLoader.loadClass(...) in getProxyClass() to ProxyClassLoadingDelegate.loadClass(classLoader, ...)
* - changes call ClassFileUtils.toClass() in createProxyClass() to ProxyClassLoadingDelegate.loadClass(...)
*
* @param ctClass the ProxyFactory class
* @param classPool the class pool
* @throws NotFoundException the not found exception
* @throws CannotCompileException the cannot compile exception
*/
@OnClassLoadEvent(classNameRegexp = "org.apache.webbeans.proxy.AbstractProxyFactory")
public static void patchProxyFactory(CtClass ctClass, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
if (HaCdiCommons.isJakarta(classPool)) {
return;
}
CtMethod getProxyClassMethod = ctClass.getDeclaredMethod("getUnusedProxyClassName");
getProxyClassMethod.instrument(
new ExprEditor() {
public void edit(MethodCall m) throws CannotCompileException {
if (m.getClassName().equals(Class.class.getName()) && m.getMethodName().equals("forName"))
m.replace("{ $_ = org.hotswap.agent.plugin.owb.command.ProxyClassLoadingDelegate.forName($$); }");
}
});
CtMethod createProxyClassMethod = ctClass.getDeclaredMethod("createProxyClass", new CtClass[] {
classPool.get(ClassLoader.class.getName()),
classPool.get(String.class.getName()),
classPool.get(Class.class.getName()),
classPool.get(Method.class.getName() + "[]"),
classPool.get(Method.class.getName() + "[]"),
classPool.get(Constructor.class.getName())
}
);
createProxyClassMethod.instrument(
new ExprEditor() {
public void edit(MethodCall m) throws CannotCompileException {
if (m.getMethodName().equals("defineAndLoadClass"))
if ("org.apache.webbeans.proxy.Unsafe".equals(m.getClassName())) {
// OWB >= 2.0.8
m.replace("{ $_ = org.hotswap.agent.plugin.owb.command.ProxyClassLoadingDelegate.defineAndLoadClassWithUnsafe(this.unsafe, $$); }");
} else {
// OWB < 2.0.8
m.replace("{ $_ = org.hotswap.agent.plugin.owb.command.ProxyClassLoadingDelegate.defineAndLoadClass(this, $$); }");
}
}
});
| 223
| 492
| 715
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/ProxyClassSignatureHelper.java
|
ProxyClassSignatureHelper
|
isPoolClassOrParentDifferent
|
class ProxyClassSignatureHelper {
private static AgentLogger LOGGER = AgentLogger.getLogger(ProxyClassSignatureHelper.class);
private static final ClassSignatureElement[] SIGNATURE_WITH_ANNO_ELEMENTS = {
ClassSignatureElement.SUPER_CLASS,
ClassSignatureElement.INTERFACES,
ClassSignatureElement.METHOD,
ClassSignatureElement.METHOD_ANNOTATION,
ClassSignatureElement.METHOD_PARAM_ANNOTATION,
ClassSignatureElement.METHOD_EXCEPTION,
};
private static final ClassSignatureElement[] SIGNATURE_ELEMENTS = {
ClassSignatureElement.SUPER_CLASS,
ClassSignatureElement.INTERFACES,
ClassSignatureElement.METHOD,
ClassSignatureElement.METHOD_EXCEPTION,
};
public static String getJavaClassSignature(Class<?> clazz) throws Exception {
return ClassSignatureComparerHelper.getJavaClassSignature(clazz, SIGNATURE_WITH_ANNO_ELEMENTS);
}
private static void addSignaturesToMap(Class<?> clazz, Map<String, String> signatureMap) {
if (clazz != null && clazz != Object.class) {
try {
String signature = getJavaClassSignature(clazz);
signatureMap.put(clazz.getName(), signature);
} catch (Exception e) {
LOGGER.error("Error reading signature", e);
}
for (Class<?> interfaceClazz : clazz.getInterfaces()) {
addSignaturesToMap(interfaceClazz, signatureMap);
}
}
}
public static Map<String, String> getNonSyntheticSignatureMap(Class<?> clazz) {
Map<String, String> signatureMap = new HashMap<>();
Class<?> parentClass = clazz.getSuperclass();
while (parentClass.isSynthetic()) {
parentClass = parentClass.getSuperclass();
}
addSignaturesToMap(parentClass, signatureMap);
for (Class<?> intr : clazz.getInterfaces()) {
addSignaturesToMap(intr, signatureMap);
}
return signatureMap;
}
public static boolean isPoolClassDifferent(Class<?> clazz, ClassPool cp) {
return ClassSignatureComparerHelper.isPoolClassDifferent(clazz, cp, SIGNATURE_ELEMENTS);
}
/**
* Checks if the CtClass or one of its parents signature differs from the one already loaded by Java.
*
* @param clazz
* @param cp
* @return
*/
public static boolean isPoolClassOrParentDifferent(Class<?> clazz, ClassPool cp) {<FILL_FUNCTION_BODY>}
/**
* Checks if the CtClass or one of its parents signature differs from the one already loaded by Java. Ignores
* synthetic classes
*
* @param classBeingRedefined
* @param cp
* @return
*/
public static boolean isNonSyntheticPoolClassOrParentDifferent(Class<?> classBeingRedefined, ClassPool cp) {
Class<?> clazz = classBeingRedefined.getSuperclass();
while (clazz.isSynthetic() || clazz.getName().contains("$Enhancer")) {
clazz = clazz.getSuperclass();
}
if (isPoolClassOrParentDifferent(clazz, cp))
return true;
Class<?>[] interfaces = classBeingRedefined.getInterfaces();
for (Class<?> intr : interfaces) {
if (isPoolClassOrParentDifferent(intr, cp))
return true;
}
return false;
}
/**
* Checks if the CtClass or one of its parents signature differs from the one already loaded by Java.
*
* @param clazz
* @param cc
* @return
*/
public static boolean isPoolClassOrParentDifferent(Class<?> clazz, CtClass cc) {
return isPoolClassDifferent(clazz, cc.getClassPool());
}
/**
* Class arrays need to be in the same order. Check if a signature of class differs from aonther. Useful for
* checking difference in different classloaders.
*
* @param classesA
* @param classesB
* @return
*/
public static boolean isDifferent(Class<?>[] classesA, Class<?>[] classesB) {
for (int i = 0; i < classesB.length; i++) {
Class<?> class1 = classesA[i];
Class<?> class2 = classesB[i];
if (ClassSignatureComparerHelper.isDifferent(class1, class2, SIGNATURE_ELEMENTS)) {
return true;
}
}
return false;
}
private static boolean isPoolClassDifferent(Class<?> clazz, ClassLoader cp) {
try {
return ClassSignatureComparerHelper.isDifferent(clazz, cp.loadClass(clazz.getName()), SIGNATURE_ELEMENTS);
} catch (ClassNotFoundException e) {
LOGGER.error("Error reading signature", e);
return false;
}
}
/**
* Checks if the Class or one of its parents signature differs from the one in the classloader.
*
* @param clazz
* @param cp
* @return
*/
public static boolean isPoolClassOrParentDifferent(Class<?> clazz, ClassLoader cp) {
if (isPoolClassDifferent(clazz, cp))
return true;
Class<?> superclass = clazz.getSuperclass();
if (superclass != null) {
if (isPoolClassOrParentDifferent(superclass, cp)) {
return true;
}
}
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> interfaceClazz : interfaces) {
if (isPoolClassOrParentDifferent(interfaceClazz, cp)) {
return true;
}
}
return false;
}
}
|
if (isPoolClassDifferent(clazz, cp))
return true;
Class<?> superclass = clazz.getSuperclass();
if (superclass != null) {
if (isPoolClassOrParentDifferent(superclass, cp)) {
return true;
}
}
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> interfaceClazz : interfaces) {
if (isPoolClassOrParentDifferent(interfaceClazz, cp)) {
return true;
}
}
return false;
| 1,538
| 145
| 1,683
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/ProxyPlugin.java
|
ProxyPlugin
|
transformJavaProxy
|
class ProxyPlugin {
private static AgentLogger LOGGER = AgentLogger.getLogger(ProxyPlugin.class);
static boolean isJava8OrNewer = WatcherFactory.JAVA_VERSION >= 18;
/**
* Flag to check reload status. In unit test we need to wait for reload
* finish before the test can continue. Set flag to true in the test class
* and wait until the flag is false again.
*/
public static boolean reloadFlag = false;
private static Set<String> proxyRedefiningMap = ConcurrentHashMap.newKeySet();
@OnClassLoadEvent(classNameRegexp = "(jdk.proxy\\d+.\\$Proxy.*)|(com.sun.proxy.\\$Proxy.*)", events = LoadEvent.REDEFINE, skipSynthetic = false)
public static void transformJavaProxy(final Class<?> classBeingRedefined, final ClassLoader classLoader) {<FILL_FUNCTION_BODY>}
public static void removeProxyDefiningClassName(String className) {
proxyRedefiningMap.remove(className);
}
@OnClassLoadEvent(classNameRegexp = ".*", events = LoadEvent.REDEFINE, skipSynthetic = false)
public static byte[] transformCglibProxy(final Class<?> classBeingRedefined, final byte[] classfileBuffer,
final ClassLoader loader, final ClassPool cp) throws Exception {
GeneratorParams generatorParams = GeneratorParametersTransformer.getGeneratorParams(loader, classBeingRedefined.getName());
if (generatorParams == null) {
return classfileBuffer;
}
if (!ClassLoaderHelper.isClassLoderStarted(loader)) {
return classfileBuffer;
}
loader.loadClass("java.beans.Introspector").getMethod("flushCaches").invoke(null);
if (generatorParams.getParam().getClass().getName().endsWith(".Enhancer")) {
try {
return CglibEnhancerProxyTransformer.transform(classBeingRedefined, cp, classfileBuffer, loader, generatorParams);
} catch (Exception e) {
LOGGER.error("Error redifining Cglib Enhancer proxy {}", e, classBeingRedefined.getName());
}
}
// Multistep transformation crashed jvm in java8 u05
if (!isJava8OrNewer) {
try {
return CglibProxyTransformer.transform(classBeingRedefined, cp, classfileBuffer, generatorParams);
}
catch (Exception e) {
LOGGER.error("Error redifining Cglib proxy {}", e, classBeingRedefined.getName());
}
}
return classfileBuffer;
}
/**
* Modifies Cglib bytecode generators to store the parameters for this plugin
*
* @throws Exception
*/
@OnClassLoadEvent(classNameRegexp = ".*/cglib/.*", skipSynthetic = false)
public static CtClass transformDefinitions(CtClass cc) throws Exception {
try {
return GeneratorParametersTransformer.transform(cc);
} catch (Exception e) {
LOGGER.error("Error modifying class for cglib proxy creation parameter recording", e);
}
return cc;
}
}
|
/*
* Proxy can't be redefined directly in this method (and return new proxy class bytes), since the classLoader contains
* OLD definition of proxie's interface. Therefore proxy is defined in deferred command (after some delay)
* after proxied interface is redefined in DCEVM.
*/
Object proxyCache = ReflectionHelper.getNoException(null, java.lang.reflect.Proxy.class, "proxyCache");
if (proxyCache != null) {
try {
ReflectionHelper.invoke(proxyCache, proxyCache.getClass().getSuperclass(), "removeAll",
new Class[] { ClassLoader.class }, classLoader);
} catch (IllegalArgumentException e) {
LOGGER.error("Reflection proxy cache flush failed. {}", e.getMessage());
}
}
if (!ClassLoaderHelper.isClassLoderStarted(classLoader)) {
return;
}
final String className = classBeingRedefined.getName();
if (proxyRedefiningMap.contains(className)) {
proxyRedefiningMap.remove(className);
return;
}
proxyRedefiningMap.add(className);
final Map<String, String> signatureMapOrig = ProxyClassSignatureHelper.getNonSyntheticSignatureMap(classBeingRedefined);
reloadFlag = true;
// TODO: can be single command if scheduler guarantees the keeping execution order in the order of redefinition
PluginManager.getInstance().getScheduler().scheduleCommand(new ReloadJavaProxyCommand(classLoader, className, signatureMapOrig), 50);
| 817
| 396
| 1,213
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/ProxyTransformationUtils.java
|
ProxyTransformationUtils
|
getClassPool
|
class ProxyTransformationUtils {
private static AgentLogger LOGGER = AgentLogger.getLogger(ProxyTransformationUtils.class);
private static Map<ClassLoader, ClassPool> classPoolMap = new WeakHashMap<>(3);
/**
* Creates one ClassPool per ClassLoader and caches it
*
* @param classLoader
* @return
*/
public static ClassPool getClassPool(ClassLoader classLoader) {<FILL_FUNCTION_BODY>}
/**
* Creates a ClassPool with supplied ClassLoader
*
* @param classLoader
* @return
*/
public static ClassPool createClassPool(final ClassLoader classLoader) {
ClassPool cp = new ClassPool() {
@Override
public ClassLoader getClassLoader() {
return classLoader;
}
};
cp.appendSystemPath();
if (classLoader != null) {
LOGGER.trace("Adding loader classpath " + classLoader);
cp.appendClassPath(new LoaderClassPath(classLoader));
}
return cp;
}
private static final int BUFFER_SIZE = 8192;
public static byte[] copyToByteArray(InputStream in) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream(BUFFER_SIZE);
try {
byte[] buffer = new byte[BUFFER_SIZE];
int bytesRead = -1;
while ((bytesRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
}
out.flush();
return out.toByteArray();
} finally {
try {
in.close();
} catch (IOException ex) {
}
try {
out.close();
} catch (IOException ex) {
}
}
}
}
|
ClassPool classPool = classPoolMap.get(classLoader);
if (classPool == null) {
synchronized (classPoolMap) {
classPool = classPoolMap.get(classLoader);
if (classPool == null) {
classPool = createClassPool(classLoader);
classPoolMap.put(classLoader, classPool);
}
}
}
return classPool;
| 459
| 104
| 563
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/RedefinitionScheduler.java
|
RedefinitionScheduler
|
run
|
class RedefinitionScheduler implements Runnable {
private MultistepProxyTransformer transformer;
@Init
private static Instrumentation instrumentation;
public RedefinitionScheduler(MultistepProxyTransformer transformer) {
this.transformer = transformer;
}
@Override
public void run() {<FILL_FUNCTION_BODY>}
public static void schedule(MultistepProxyTransformer multistepProxyTransformer) {
new Thread(new RedefinitionScheduler(multistepProxyTransformer)).start();
}
}
|
try {
instrumentation.redefineClasses(new ClassDefinition(transformer.getClassBeingRedefined(), transformer
.getClassfileBuffer()));
} catch (Throwable t) {
transformer.removeClassState();
throw new RuntimeException(t);
}
| 141
| 70
| 211
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/ReloadJavaProxyCommand.java
|
ReloadJavaProxyCommand
|
executeSingleCommand
|
class ReloadJavaProxyCommand extends MergeableCommand {
private static AgentLogger LOGGER = AgentLogger.getLogger(ReloadJavaProxyCommand.class);
private ClassLoader classLoader;
private String className;
private Map<String, String> signatureMapOrig;
public ReloadJavaProxyCommand(ClassLoader classLoader, String className, Map<String, String> signatureMapOrig) {
this.classLoader = classLoader;
this.className = className;
this.signatureMapOrig = signatureMapOrig;
}
@Override
public void executeCommand() {
try {
executeSingleCommand();
List<Command> commands = new ArrayList<>(getMergedCommands());
for (Command command: commands) {
((ReloadJavaProxyCommand) command).executeSingleCommand();
}
} finally {
ProxyPlugin.reloadFlag = false;
}
}
public void executeSingleCommand() {<FILL_FUNCTION_BODY>}
// Whether all methods of the interface are implemented
private boolean isImplementInterface(Map<String, String> signatureMap, Class<?> clazz) {
String clazzSignature = "";
try {
clazzSignature = ProxyClassSignatureHelper.getJavaClassSignature(clazz).replaceAll("final ", "");
LOGGER.debug("clazzSignature: {}", clazzSignature);
} catch (Exception e) {
LOGGER.error("Error getJavaClassSignature {}", clazz, e);
return true;
}
for (Map.Entry<String, String> entry : signatureMap.entrySet()) {
if(clazzSignature.contains(entry.getKey()) && entry.getValue().contains("public abstract")) {
LOGGER.debug("{} Signature: {}", entry.getKey(), entry.getValue());
String[] methodSignatures = entry.getValue().replaceAll("abstract ", "").split(";");
for (String methodSignature : methodSignatures) {
if(!clazzSignature.contains(methodSignature)) {
return false;
}
}
}
}
return true;
}
public boolean shiftScheduleTime() {
return false;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ReloadJavaProxyCommand that = (ReloadJavaProxyCommand) o;
if (!classLoader.equals(that.classLoader)) return false;
return true;
}
@Override
public int hashCode() {
int result = classLoader.hashCode();
return result;
}
@Override
public String toString() {
return "ReloadJavaProxyCommand{" + "classLoader=" + classLoader + '}';
}
}
|
try {
Class<?> clazz = classLoader.loadClass(className);
Map<String, String> signatureMap = ProxyClassSignatureHelper.getNonSyntheticSignatureMap(clazz);
LOGGER.debug("executeSingleCommand class:{}, signature equals:{}", className, signatureMap.equals(signatureMapOrig));
if (!signatureMap.equals(signatureMapOrig) || !isImplementInterface(signatureMap, clazz)) {
byte[] generateProxyClass = ProxyGenerator.generateProxyClass(className, clazz.getInterfaces());
Map<Class<?>, byte[]> reloadMap = new HashMap<>();
reloadMap.put(clazz, generateProxyClass);
PluginManager.getInstance().hotswap(reloadMap);
LOGGER.reload("Class '{}' has been reloaded.", className);
}
} catch (ClassNotFoundException e) {
LOGGER.error("Error redefining java proxy {}", e, className);
}
| 703
| 242
| 945
|
<methods>public non-sealed void <init>() ,public List<org.hotswap.agent.command.Command> getMergedCommands() ,public org.hotswap.agent.command.Command merge(org.hotswap.agent.command.Command) ,public List<org.hotswap.agent.command.Command> popMergedCommands() <variables>List<org.hotswap.agent.command.Command> mergedCommands
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/api/AbstractProxyBytecodeTransformer.java
|
AbstractProxyBytecodeTransformer
|
addInitCallToMethods
|
class AbstractProxyBytecodeTransformer implements ProxyBytecodeTransformer
{
private ClassPool classPool;
/**
*
* @param classPool
* Classpool used to make a CtClass
*/
public AbstractProxyBytecodeTransformer(ClassPool classPool) {
this.classPool = classPool;
}
public byte[] transform(byte[] byteCode) throws Exception {
CtClass cc = classPool.makeClass(new ByteArrayInputStream(byteCode), false);
try {
String initFieldName = INIT_FIELD_PREFIX + generateRandomString();
addStaticInitStateField(cc, initFieldName);
String initCode = getInitCall(cc, initFieldName);
addInitCallToMethods(cc, initFieldName, initCode);
return cc.toBytecode();
} finally {
cc.detach();
}
}
/**
* Builds the Java code String which should be executed to initialize the proxy
*
* @param cc
* CtClass from new definition
* @param random
* randomly generated String
* @return Java code to call init the proxy
*/
protected abstract String getInitCall(CtClass cc, String random) throws Exception;
protected String generateRandomString() {
return UUID.randomUUID().toString().replace("-", "");
}
/**
* Adds the initCall as Java code to all the non static methods of the class. The initialization is only done if
* clinitFieldName is false. Responsibility to set the clinitFieldName is on the initCall.
*
* @param cc
* CtClass to be modified
* @param clinitFieldName
* field name in CtClass
* @param initCall
* Java code to initialize the Proxy
* @throws Exception
*/
protected void addInitCallToMethods(CtClass cc, String clinitFieldName, String initCall) throws Exception {<FILL_FUNCTION_BODY>}
/**
* Adds a static boolean field to the class indicating the state of initialization
*
* @param cc
* CtClass to be modified
* @param clinitFieldName
* field name in CtClass
* @throws Exception
*/
protected void addStaticInitStateField(CtClass cc, String clinitFieldName) throws Exception {
CtField f = new CtField(CtClass.booleanType, clinitFieldName, cc);
f.setModifiers(Modifier.PRIVATE | Modifier.STATIC);
// init value "true" will be inside clinit, so the field wont actually be initialized on redefinition
cc.addField(f, "true");
}
}
|
CtMethod[] methods = cc.getDeclaredMethods();
for (CtMethod ctMethod : methods) {
if (!ctMethod.isEmpty() && !Modifier.isStatic(ctMethod.getModifiers())) {
ctMethod.insertBefore("if(!" + clinitFieldName + "){synchronized(" + cc.getName() + ".class){if(!"
+ clinitFieldName + "){" + initCall + "}}}");
}
}
| 681
| 117
| 798
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/api/AbstractProxyTransformer.java
|
AbstractProxyTransformer
|
getTransformer
|
class AbstractProxyTransformer implements ProxyTransformer
{
public AbstractProxyTransformer(Class<?> classBeingRedefined, ClassPool classPool) {
super();
this.classBeingRedefined = classBeingRedefined;
this.classPool = classPool;
}
protected ProxyBytecodeGenerator generator;
protected ProxyBytecodeTransformer transformer;
protected Class<?> classBeingRedefined;
protected ClassPool classPool;
protected ProxyBytecodeGenerator getGenerator() {
if (generator == null) {
generator = createGenerator();
}
return generator;
}
protected ProxyBytecodeTransformer getTransformer() {<FILL_FUNCTION_BODY>}
/**
* creates a new ProxyBytecodeGenerator insatance for use in this transformer
*
* @return
*/
protected abstract ProxyBytecodeGenerator createGenerator();
/**
* creates a new ProxyBytecodeTransformer insatance for use in this transformer
*
* @return
*/
protected abstract ProxyBytecodeTransformer createTransformer();
/**
* Checks if there were changes that require the redefinition of the proxy
*
* @return true if there wre changes that require redefinition
*/
protected boolean isTransformingNeeded() {
return ProxyClassSignatureHelper.isNonSyntheticPoolClassOrParentDifferent(classBeingRedefined, classPool);
}
}
|
if (transformer == null) {
transformer = createTransformer();
}
return transformer;
| 363
| 29
| 392
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/api/MultistepProxyTransformer.java
|
MultistepProxyTransformer
|
transformRedefine
|
class MultistepProxyTransformer extends AbstractProxyTransformer
{
private static final AgentLogger LOGGER = AgentLogger.getLogger(MultistepProxyTransformer.class);
public static boolean addThirdStep = false;
protected byte[] classfileBuffer;
protected Map<Class<?>, TransformationState> transformationStates;
protected ProxyBytecodeGenerator generator;
protected ProxyBytecodeTransformer transformer;
public MultistepProxyTransformer(Class<?> classBeingRedefined, ClassPool classPool, byte[] classfileBuffer,
Map<Class<?>, TransformationState> transformationStates) {
super(classBeingRedefined, classPool);
this.classPool = classPool;
this.transformationStates = transformationStates;
this.classfileBuffer = classfileBuffer;
}
/**
* Handles the current transformation state
*
* @return
* @throws Exception
*/
public byte[] transformRedefine() throws Exception {<FILL_FUNCTION_BODY>}
/**
* @return Current transformation state of the classBeingRedefined
*/
protected TransformationState getTransformationstate() {
TransformationState transformationState = transformationStates.get(classBeingRedefined);
if (transformationState == null)
transformationState = TransformationState.NEW;
return transformationState;
}
/**
* Generate new redefinition event for current classBeingRedefined
*/
protected void scheduleRedefinition() {
RedefinitionScheduler.schedule(this);
}
/**
* Set classBeingRedefined as waiting
*
* @return
*/
protected TransformationState setClassAsWaiting() {
return transformationStates.put(classBeingRedefined, TransformationState.WAITING);
}
/**
* Set classBeingRedefined as finished
*
* @return
*/
protected TransformationState setClassAsFinished() {
return transformationStates.put(classBeingRedefined, TransformationState.FINISHED);
}
/**
* Remove any state associated with classBeingRedefined
*
* @return
*/
public TransformationState removeClassState() {
return transformationStates.remove(classBeingRedefined);
}
/**
* The Class this instance is redefining
*
* @return
*/
public Class<?> getClassBeingRedefined() {
return classBeingRedefined;
}
/**
* Bytecode of the Class this instance is redefining.
*
* @return
*/
public byte[] getClassfileBuffer() {
return classfileBuffer;
}
}
|
switch (getTransformationstate()) {
case NEW:
if (!isTransformingNeeded()) {
return classfileBuffer;
}
setClassAsWaiting();
// We can't do the transformation in this event, because we can't see the changes in the class
// definitons. Schedule a new redefinition event.
scheduleRedefinition();
return classfileBuffer;
case WAITING:
classfileBuffer = getTransformer().transform(getGenerator().generate());
LOGGER.reload("Class '{}' has been reloaded.", classBeingRedefined.getName());
if (addThirdStep) {
setClassAsFinished();
scheduleRedefinition();
} else
removeClassState();
return classfileBuffer;
case FINISHED:
removeClassState();
return classfileBuffer;
default:
throw new RuntimeException("Unhandeled TransformationState!");
}
| 684
| 235
| 919
|
<methods>public void <init>(Class<?>, org.hotswap.agent.javassist.ClassPool) <variables>protected Class<?> classBeingRedefined,protected org.hotswap.agent.javassist.ClassPool classPool,protected org.hotswap.agent.plugin.proxy.api.ProxyBytecodeGenerator generator,protected org.hotswap.agent.plugin.proxy.api.ProxyBytecodeTransformer transformer
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/api/SinglestepProxyTransformer.java
|
SinglestepProxyTransformer
|
transformRedefine
|
class SinglestepProxyTransformer extends AbstractProxyTransformer
{
private static final AgentLogger LOGGER = AgentLogger.getLogger(SinglestepProxyTransformer.class);
protected byte[] classfileBuffer;
public SinglestepProxyTransformer(Class<?> classBeingRedefined, ClassPool classPool, byte[] classfileBuffer) {
super(classBeingRedefined, classPool);
this.classfileBuffer = classfileBuffer;
}
/**
* Handles the current transformation state
*
* @return
* @throws Exception
*/
public byte[] transformRedefine() throws Exception {<FILL_FUNCTION_BODY>}
}
|
if (!isTransformingNeeded()) {
return classfileBuffer;
}
classfileBuffer = getTransformer().transform(getGenerator().generate());
LOGGER.reload("Class '{}' has been reloaded.", classBeingRedefined.getName());
return classfileBuffer;
| 168
| 73
| 241
|
<methods>public void <init>(Class<?>, org.hotswap.agent.javassist.ClassPool) <variables>protected Class<?> classBeingRedefined,protected org.hotswap.agent.javassist.ClassPool classPool,protected org.hotswap.agent.plugin.proxy.api.ProxyBytecodeGenerator generator,protected org.hotswap.agent.plugin.proxy.api.ProxyBytecodeTransformer transformer
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/hscglib/CglibEnhancerProxyBytecodeGenerator.java
|
FieldState
|
loadFromClassloader
|
class FieldState {
public FieldState(Field field, Object fieldValue) {
this.field = field;
this.fieldValue = fieldValue;
}
private Field field;
private Object fieldValue;
}
/**
* Generates bytecode for the proxy class
*
* @return bytecode of the new proxy class
* @throws Exception
*/
@Override
public byte[] generate() throws Exception {
Collection<FieldState> oldClassValues = getFieldValuesWithClasses();
ClassLoader oldClassLoader = (ClassLoader) ReflectionHelper
.get(generator, "classLoader");
Boolean oldUseCache = (Boolean) ReflectionHelper.get(generator,
"useCache");
try {
ReflectionHelper.set(generator, abstractGeneratorClass,
"classLoader", classLoader);
ReflectionHelper.set(generator, abstractGeneratorClass, "useCache",
Boolean.FALSE);
setFieldValuesWithNewLoadedClasses(oldClassValues);
byte[] invoke = (byte[]) ReflectionHelper.invoke(
param.getGenerator(), param.getGenerator().getClass(),
"generate", new Class[] { getGeneratorInterfaceClass() },
generator);
return invoke;
} finally {
ReflectionHelper.set(generator, abstractGeneratorClass,
"classLoader", oldClassLoader);
ReflectionHelper.set(generator, abstractGeneratorClass, "useCache",
oldUseCache);
setFieldValues(oldClassValues);
}
}
/**
*
* @return ClassGenerator interface Class instance
*/
private Class<?> getGeneratorInterfaceClass() {
Class<?>[] interfaces = abstractGeneratorClass.getInterfaces();
for (Class<?> iClass : interfaces) {
if (iClass.getName().endsWith(".ClassGenerator"))
return iClass;
}
return null;
}
private void setFieldValues(Collection<FieldState> fieldStates)
throws IllegalAccessException {
for (FieldState fieldState : fieldStates) {
fieldState.field.set(generator, fieldState.fieldValue);
}
}
/**
* replaces fields with Class values with new classes loaded by a
* ParentLastClassLoader
*
* @param fieldStates
* @throws IllegalAccessException
* @throws ClassNotFoundException
*/
private void setFieldValuesWithNewLoadedClasses(
Collection<FieldState> fieldStates)
throws IllegalAccessException, ClassNotFoundException {
for (FieldState fieldState : fieldStates) {
fieldState.field.set(generator,
loadFromClassloader(fieldState.fieldValue));
}
}
private Collection<FieldState> getFieldValuesWithClasses()
throws IllegalAccessException {
Collection<FieldState> classValueFields = new ArrayList<FieldState>();
Field[] fields = generatorClass.getDeclaredFields();
for (Field field : fields) {
if (!Modifier.isStatic(field.getModifiers())
&& (field.getType().isInstance(Class.class)
|| field.getType().isInstance(Class[].class))) {
field.setAccessible(true);
classValueFields
.add(new FieldState(field, field.get(generator)));
}
}
return classValueFields;
}
/**
* Load classes from ParentLastClassLoader
*
* @param fieldState
* @return
* @throws ClassNotFoundException
*/
private Object loadFromClassloader(Object fieldState)
throws ClassNotFoundException {<FILL_FUNCTION_BODY>
|
if (fieldState instanceof Class[]) {
Class<?>[] classes = ((Class[]) fieldState);
Class<?>[] newClasses = new Class[classes.length];
for (int i = 0; i < classes.length; i++) {
Class<?> loadClass = classLoader
.loadClass(classes[i].getName());
newClasses[i] = loadClass;
}
return newClasses;
} else {
if (fieldState instanceof Class) {
return classLoader.loadClass(((Class<?>) fieldState).getName());
}
}
return fieldState;
| 893
| 156
| 1,049
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/hscglib/CglibProxyBytecodeGenerator.java
|
CglibProxyBytecodeGenerator
|
generate
|
class CglibProxyBytecodeGenerator implements ProxyBytecodeGenerator {
private GeneratorParams params;
public CglibProxyBytecodeGenerator(GeneratorParams params) {
super();
this.params = params;
}
public byte[] generate() throws Exception {<FILL_FUNCTION_BODY>}
/**
* Retrieves the actual Method that generates and returns the bytecode
*
* @param generator
* GeneratorStrategy instance
* @return Method that generates and returns the bytecode
*/
private Method getGenerateMethod(Object generator) {
Method[] methods = generator.getClass().getMethods();
for (Method method : methods) {
if (method.getName().equals("generate")
&& method.getReturnType().getSimpleName().equals("byte[]")
&& method.getParameterTypes().length == 1) {
return method;
}
}
return null;
}
}
|
Method genMethod = getGenerateMethod(params.getGenerator());
if (genMethod == null)
throw new RuntimeException(
"No generation Method found for redefinition!");
return (byte[]) genMethod.invoke(params.getGenerator(),
params.getParam());
| 234
| 71
| 305
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/hscglib/CglibProxyBytecodeTransformer.java
|
CglibProxyBytecodeTransformer
|
getInitCall
|
class CglibProxyBytecodeTransformer
extends AbstractProxyBytecodeTransformer {
public CglibProxyBytecodeTransformer(ClassPool classPool) {
super(classPool);
}
@Override
protected String getInitCall(CtClass cc, String initFieldName)
throws Exception {<FILL_FUNCTION_BODY>}
}
|
CtMethod[] methods = cc.getDeclaredMethods();
StringBuilder strB = new StringBuilder();
for (CtMethod ctMethod : methods) {
if (ctMethod.getName().startsWith("CGLIB$STATICHOOK")) {
ctMethod.insertAfter(initFieldName + "=true;");
strB.insert(0, ctMethod.getName() + "();");
break;
}
}
if (strB.length() == 0)
throw new RuntimeException(
"Could not find CGLIB$STATICHOOK method");
return strB.toString() + "CGLIB$BIND_CALLBACKS(this);";
| 90
| 173
| 263
|
<methods>public void <init>(org.hotswap.agent.javassist.ClassPool) ,public byte[] transform(byte[]) throws java.lang.Exception<variables>private org.hotswap.agent.javassist.ClassPool classPool
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/hscglib/GeneratorParametersRecorder.java
|
GeneratorParametersRecorder
|
getClassName
|
class GeneratorParametersRecorder {
// this Map is used in the App ClassLoader
public static ConcurrentHashMap<String, GeneratorParams> generatorParams = new ConcurrentHashMap<>();
private static AgentLogger LOGGER = AgentLogger
.getLogger(GeneratorParametersRecorder.class);
/**
*
* @param generatorStrategy
* Cglib generator strategy instance that generated the bytecode
* @param classGenerator
* parameter used to generate the bytecode with generatorStrategy
* @param bytes
* generated bytecode
*/
public static void register(Object generatorStrategy, Object classGenerator,
byte[] bytes) {
try {
generatorParams.putIfAbsent(getClassName(bytes),
new GeneratorParams(generatorStrategy, classGenerator));
} catch (Exception e) {
LOGGER.error(
"Error saving parameters of a creation of a Cglib proxy",
e);
}
}
/**
* http://stackoverflow.com/questions/1649674/resolve-class-name-from-bytecode
*
* @param bytes
* @return
* @throws Exception
*/
public static String getClassName(byte[] bytes) throws Exception {<FILL_FUNCTION_BODY>}
}
|
DataInputStream dis = new DataInputStream(
new ByteArrayInputStream(bytes));
dis.readLong(); // skip header and class version
int cpcnt = (dis.readShort() & 0xffff) - 1;
int[] classes = new int[cpcnt];
String[] strings = new String[cpcnt];
for (int i = 0; i < cpcnt; i++) {
int t = dis.read();
if (t == 7)
classes[i] = dis.readShort() & 0xffff;
else if (t == 1)
strings[i] = dis.readUTF();
else if (t == 5 || t == 6) {
dis.readLong();
i++;
} else if (t == 8)
dis.readShort();
else
dis.readInt();
}
dis.readShort(); // skip access flags
return strings[classes[(dis.readShort() & 0xffff) - 1] - 1].replace('/',
'.');
| 319
| 259
| 578
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/hscglib/GeneratorParametersTransformer.java
|
GeneratorParametersTransformer
|
transform
|
class GeneratorParametersTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(GeneratorParametersTransformer.class);
private static Map<ClassLoader, WeakReference<Map<String, Object>>> classLoaderMaps = new WeakHashMap<ClassLoader, WeakReference<Map<String, Object>>>();
/**
* Adds bytecode generation call parameter recording
*
* @param cc
* @return
* @throws Exception
*/
public static CtClass transform(CtClass cc) throws Exception {<FILL_FUNCTION_BODY>}
/**
* Determines if a Class is a Cglib GeneratorStrategy subclass
*
* @param cc
* @return
*/
private static boolean isGeneratorStrategy(CtClass cc) {
String[] interfaces = cc.getClassFile2().getInterfaces();
for (String interfaceName : interfaces) {
// We use class name strings because some libraries repackage cglib to a different namespace to avoid
// conflicts.
if (interfaceName.endsWith(".GeneratorStrategy")) {
List<MethodInfo> methodInfos = cc.getClassFile2().getMethods();
for (MethodInfo method : methodInfos) {
if (method.getName().equals("generate") && method.getDescriptor().endsWith("[B")) {
return true;
}
}
}
}
return false;
}
/**
* Retrieves GeneratorParams Map from within a ClassLoader
*
* @param loader
* @return Map of Class names and parameters used for Proxy creation
*/
@SuppressWarnings("unchecked")
private static Map<String, Object> getGeneratorParamsMap(ClassLoader loader) {
try {
WeakReference<Map<String, Object>> mapRef;
synchronized (classLoaderMaps) {
mapRef = classLoaderMaps.get(loader);
if (mapRef == null) {
if (ClassLoaderHelper.isClassLoderStarted(loader)) {
Map<String, Object> map = (Map<String, Object>) loader
.loadClass(GeneratorParametersRecorder.class.getName()).getField("generatorParams")
.get(null);
mapRef = new WeakReference<Map<String, Object>>(map);
classLoaderMaps.put(loader, mapRef);
}
}
}
Map<String, Object> map = mapRef != null ? mapRef.get() : null;
if (map == null) {
return new HashMap<>();
}
return map;
} catch (IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException
| ClassNotFoundException e) {
LOGGER.error("Unable to access field with proxy generation parameters. Proxy redefinition failed.");
throw new RuntimeException(e);
}
}
/**
* Retrieves GeneratorParams from within a ClassLoader
*
* @param loader
* @param name
* Class name
* @return GeneratorParams instance in this ClassLoader
*/
public static GeneratorParams getGeneratorParams(ClassLoader loader, String name) {
Object generatorParams = getGeneratorParamsMap(loader).get(name);
if (generatorParams != null) {
try {
return GeneratorParams.valueOf(generatorParams);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
return null;
}
}
|
if (isGeneratorStrategy(cc)) {
for (CtMethod method : cc.getDeclaredMethods()) {
if (!Modifier.isAbstract(method.getModifiers()) && method.getName().equals("generate")
&& method.getMethodInfo().getDescriptor().endsWith(";)[B")) {
cc.defrost();
method.insertAfter("org.hotswap.agent.plugin.proxy.hscglib.GeneratorParametersRecorder.register($0, $1, $_);");
}
}
}
return cc;
| 858
| 139
| 997
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/hscglib/GeneratorParams.java
|
GeneratorParams
|
valueOf
|
class GeneratorParams {
private Object generator;
private Object param;
public GeneratorParams(Object generator, Object param) {
this.generator = generator;
this.param = param;
}
public Object getGenerator() {
return generator;
}
public void setGenerator(Object generator) {
this.generator = generator;
}
public Object getParam() {
return param;
}
public void setParam(Object params) {
this.param = params;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((generator == null) ? 0 : generator.hashCode());
result = prime * result + ((param == null) ? 0 : param.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
GeneratorParams other = (GeneratorParams) obj;
if (generator == null) {
if (other.generator != null)
return false;
} else if (!generator.equals(other.generator))
return false;
if (param == null) {
if (other.param != null)
return false;
} else if (!param.equals(other.param))
return false;
return true;
}
/**
* Return an instance in this classloader
*
* @param paramsFromOtherClassLoader
* instamce in another classlaoder
* @return instance in this classloader
* @throws Exception
*/
public static GeneratorParams valueOf(Object paramsFromOtherClassLoader)
throws Exception {<FILL_FUNCTION_BODY>}
}
|
if (paramsFromOtherClassLoader.getClass()
.getClassLoader() == GeneratorParams.class.getClassLoader()) {
return (GeneratorParams) paramsFromOtherClassLoader;
}
Object params = ReflectionHelper.get(paramsFromOtherClassLoader,
"param");
Object generator = ReflectionHelper.get(paramsFromOtherClassLoader,
"generator");
return new GeneratorParams(generator, params);
| 478
| 107
| 585
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-proxy-plugin/src/main/java/org/hotswap/agent/plugin/proxy/hscglib/ParentLastClassLoader.java
|
ParentLastClassLoader
|
loadClass
|
class ParentLastClassLoader extends ClassLoader {
public static final String[] EXCLUDED_PACKAGES = new String[] { "java.", "javax.", "sun.", "oracle." };
public ParentLastClassLoader(ClassLoader parent) {
super(parent);
}
@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {<FILL_FUNCTION_BODY>}
protected Class<?> loadClassFromThisClassLoader(String name) throws ClassNotFoundException {
Class<?> result = findLoadedClass(name);
if (result != null) {
return result;
}
byte[] bytes = readClass(name);
if (bytes != null) {
return defineClass(name, bytes, 0, bytes.length);
}
return null;
}
protected byte[] readClass(String name) throws ClassNotFoundException {
InputStream is = getParent().getResourceAsStream(name.replace('.', '/') + ".class");
if (is == null) {
return null;
}
try {
return ProxyTransformationUtils.copyToByteArray(is);
} catch (IOException ex) {
throw new ClassNotFoundException("Could not read: " + name, ex);
}
}
}
|
for (String excludedPackage : EXCLUDED_PACKAGES) {
if (name.startsWith(excludedPackage))
return super.loadClass(name, resolve);
}
Class<?> clazz = loadClassFromThisClassLoader(name);
if (clazz == null)
return super.loadClass(name, resolve);
if (resolve) {
resolveClass(clazz);
}
return clazz;
| 325
| 115
| 440
|
<methods>public void clearAssertionStatus() ,public final java.lang.Package getDefinedPackage(java.lang.String) ,public final java.lang.Package[] getDefinedPackages() ,public java.lang.String getName() ,public final java.lang.ClassLoader getParent() ,public static java.lang.ClassLoader getPlatformClassLoader() ,public java.net.URL getResource(java.lang.String) ,public java.io.InputStream getResourceAsStream(java.lang.String) ,public Enumeration<java.net.URL> getResources(java.lang.String) throws java.io.IOException,public static java.lang.ClassLoader getSystemClassLoader() ,public static java.net.URL getSystemResource(java.lang.String) ,public static java.io.InputStream getSystemResourceAsStream(java.lang.String) ,public static Enumeration<java.net.URL> getSystemResources(java.lang.String) throws java.io.IOException,public final java.lang.Module getUnnamedModule() ,public final boolean isRegisteredAsParallelCapable() ,public Class<?> loadClass(java.lang.String) throws java.lang.ClassNotFoundException,public Stream<java.net.URL> resources(java.lang.String) ,public void setClassAssertionStatus(java.lang.String, boolean) ,public void setDefaultAssertionStatus(boolean) ,public void setPackageAssertionStatus(java.lang.String, boolean) <variables>static final boolean $assertionsDisabled,final java.lang.Object assertionLock,Map<java.lang.String,java.lang.Boolean> classAssertionStatus,private volatile ConcurrentHashMap<?,?> classLoaderValueMap,private final ArrayList<Class<?>> classes,private boolean defaultAssertionStatus,private final java.security.ProtectionDomain defaultDomain,private final jdk.internal.loader.NativeLibraries libraries,private final java.lang.String name,private final java.lang.String nameAndId,private static final java.security.cert.Certificate[] nocerts,private final ConcurrentHashMap<java.lang.String,java.security.cert.Certificate[]> package2certs,private Map<java.lang.String,java.lang.Boolean> packageAssertionStatus,private final ConcurrentHashMap<java.lang.String,java.lang.NamedPackage> packages,private final ConcurrentHashMap<java.lang.String,java.lang.Object> parallelLockMap,private final java.lang.ClassLoader parent,private static volatile java.lang.ClassLoader scl,private final java.lang.Module unnamedModule
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-resteasy-registry-plugin/src/main/java/org/hotswap/agent/plugin/resteasy/RefreshRegistryCommand.java
|
RefreshRegistryCommand
|
executeCommand
|
class RefreshRegistryCommand extends MergeableCommand {
private static AgentLogger LOGGER = AgentLogger.getLogger(RefreshRegistryCommand.class);
private ClassLoader classLoader;
private ServletContext context;
private String className;
private ServletContainerDispatcher servletContainerDispatcher;
private Class<?> original;
public void setupCmd(ClassLoader classLoader, Object context, Object servletContainerDispatcher, String className, Class<?> original) {
this.classLoader = classLoader;
this.context = (ServletContext) context;
this.servletContainerDispatcher = (ServletContainerDispatcher) servletContainerDispatcher;
this.className = className;
this.original = original;
}
@Override
public void executeCommand() {<FILL_FUNCTION_BODY>}
@SuppressWarnings("unchecked")
private <T> T get(ResourceMethodRegistry rm, String field) {
Class<?> c;
try {
c = classLoader.loadClass(ResourceMethodRegistry.class.getName());
Field f = c.getField(field);
return (T) f.get(rm);
} catch (ClassNotFoundException | NoSuchFieldException | SecurityException | IllegalArgumentException
| IllegalAccessException e) {
LOGGER.error("Could not get field {}", e, field);
}
return null;
}
private void removeRegistration(ResourceMethodRegistry rm, String path, Method method) {
try {
if (rm.isWiderMatching()) {
RootNode rootNode = get(rm, "rootNode");
rootNode.removeBinding(path, method);
} else {
String methodpath = method.getAnnotation(Path.class).value();
String classExpression = path.replace(methodpath, "");
if (classExpression.endsWith("/")) {
classExpression.substring(0, classExpression.length() - 1);
}
RootClassNode root = get(rm, "root");
root.removeBinding(classExpression, path, method);
}
} catch (Exception e) {
LOGGER.error("Could not remove method registration from path {}, {}", e, path, method);
}
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((classLoader == null) ? 0 : classLoader.hashCode());
result = prime * result + ((className == null) ? 0 : className.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
RefreshRegistryCommand other = (RefreshRegistryCommand) obj;
if (classLoader == null) {
if (other.classLoader != null)
return false;
} else if (!classLoader.equals(other.classLoader))
return false;
if (className == null) {
if (other.className != null)
return false;
} else if (!className.equals(other.className))
return false;
return true;
}
@Override
public String toString() {
return "RefreshRegistryCommand [classLoader=" + classLoader + ", className=" + className + "]";
}
}
|
ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
LOGGER.debug("Re-Loading class: {} , {} , {}", className, oldClassLoader, classLoader);
Thread.currentThread().setContextClassLoader(classLoader);
try {
Registry registry = (Registry) context.getAttribute(Registry.class.getName());
if (registry == null) {
registry = servletContainerDispatcher.getDispatcher().getRegistry();
}
//Does original actually represent the... original class????
if(original != null) {
registry.removeRegistrations(original);
}
Class<?> c = classLoader.loadClass(className);
//Remove all matching registrations (between old and new class..)
registry.removeRegistrations(c);
//Iterate over all known methods for this className
if (registry instanceof ResourceMethodRegistry) {
ResourceMethodRegistry rm = ResourceMethodRegistry.class.cast(registry);
Map<String, List<ResourceInvoker>> bounded = rm.getBounded();
for (Entry<String, List<ResourceInvoker>> e : bounded.entrySet()) {
LOGGER.debug("Examining {}", e.getKey());
for (ResourceInvoker r : e.getValue()) {
if(LOGGER.isLevelEnabled(Level.DEBUG)){
LOGGER.debug("Examining {} for method {} in class {}", e.getKey(), r.getMethod().getName(),
r.getMethod().getDeclaringClass());
}
if (r.getMethod().getDeclaringClass().getName().equals(className)) {
removeRegistration(rm, e.getKey(), r.getMethod());
}
}
}
}
//Add the new resource
registry.addPerRequestResource(c);
} catch (Exception e) {
LOGGER.error("Could not reload rest class {}", e, className);
} finally {
Thread.currentThread().setContextClassLoader(oldClassLoader);
}
| 857
| 498
| 1,355
|
<methods>public non-sealed void <init>() ,public List<org.hotswap.agent.command.Command> getMergedCommands() ,public org.hotswap.agent.command.Command merge(org.hotswap.agent.command.Command) ,public List<org.hotswap.agent.command.Command> popMergedCommands() <variables>List<org.hotswap.agent.command.Command> mergedCommands
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-resteasy-registry-plugin/src/main/java/org/hotswap/agent/plugin/resteasy/ResteasyRegistryPlugin.java
|
ResteasyRegistryPlugin
|
refreshClass
|
class ResteasyRegistryPlugin {
private static AgentLogger LOGGER = AgentLogger.getLogger(ResteasyRegistryPlugin.class);
private static final String PATH_ANNOTATION = "javax.ws.rs.Path";
@Init
ClassLoader appClassLoader;
@Init
Scheduler scheduler;
Object servletContext;
Object servletContainerDispatcher;
/**
* Patch ResourceMethodRegistry, make rootNode && root fields public
*
* @param ctClass
* @param classPool
*/
@OnClassLoadEvent(classNameRegexp = "org.jboss.resteasy.core.ResourceMethodRegistry")
public static void patchResourceMethodRegistry(CtClass ctClass, ClassPool classPool) {
try {
// Make ResourceMethodRegistry root nodes readable
ctClass.getField("rootNode").setModifiers(AccessFlag.PUBLIC);
ctClass.getField("root").setModifiers(AccessFlag.PUBLIC);
} catch (NotFoundException e) {
LOGGER.error("Error patching FilterDispatcher", e);
}
}
/**
*
* @param ctClass
* @param classPool
*/
@OnClassLoadEvent(classNameRegexp = "org.jboss.resteasy.plugins.server.servlet.FilterDispatcher")
public static void patchFilterDispatcher(CtClass ctClass, ClassPool classPool) {
try{
CtMethod init = ctClass.getDeclaredMethod("init");
init.insertAfter(""//
+"java.lang.ClassLoader $$cl = Thread.currentThread().getContextClassLoader();" //
+"java.lang.Object $$servletContext = servletConfig.getServletContext();"//
+ PluginManagerInvoker.buildInitializePlugin(ResteasyRegistryPlugin.class, "$$cl")//
+ PluginManagerInvoker.buildCallPluginMethod("$$cl", ResteasyRegistryPlugin.class,
"registerContext", "$$servletContext", "java.lang.Object")//
+ PluginManagerInvoker.buildCallPluginMethod("$$cl", ResteasyRegistryPlugin.class,
"registerServletContainerDispatcher", "servletContainerDispatcher", "java.lang.Object")//
);
} catch(NotFoundException | CannotCompileException e){
LOGGER.error("Error patching FilterDispatcher", e);
}
}
@OnClassLoadEvent(classNameRegexp = "org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher")
public static void patchServletDispatcher(CtClass ctClass, ClassPool classPool){
try{
CtMethod init = ctClass.getDeclaredMethod("init");
init.insertAfter(""//
+ "java.lang.Object $$servletContext = servletConfig.getServletContext();" //
+ "java.lang.ClassLoader $$cl = Thread.currentThread().getContextClassLoader();"//
+ PluginManagerInvoker.buildInitializePlugin(ResteasyRegistryPlugin.class, "$$cl") //
+ PluginManagerInvoker.buildCallPluginMethod("$$cl", ResteasyRegistryPlugin.class,
"registerContext", "$$servletContext", "java.lang.Object") //
+ PluginManagerInvoker.buildCallPluginMethod("$$cl", ResteasyRegistryPlugin.class,
"registerServletContainerDispatcher", "servletContainerDispatcher", "java.lang.Object")//
);
} catch(NotFoundException | CannotCompileException e){
LOGGER.error("Error patching HttpServletDispatcher", e);
}
}
public void registerContext(Object servletContext) {
this.servletContext = servletContext;
LOGGER.info("Registered ServletContext {} ", servletContext);
}
public void registerServletContainerDispatcher(Object servletContainerDispatcher) {
this.servletContainerDispatcher = servletContainerDispatcher;
LOGGER.info("Registered ServletContainerDispatcher {} ", servletContainerDispatcher);
}
@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)) {
if(LOGGER.isLevelEnabled(Level.TRACE)) {
LOGGER.trace("Reload @Path annotated class {}", clazz.getName());
}
refreshClass(classLoader, clazz.getName(), original, 250);
}
}
@OnClassFileEvent(classNameRegexp = ".*", events = { FileEvent.CREATE })
public void newEntity(ClassLoader classLoader, CtClass clazz) throws Exception {
if (AnnotationHelper.hasAnnotation(clazz, PATH_ANNOTATION)) {
if(LOGGER.isLevelEnabled(Level.TRACE)) {
LOGGER.trace("Load @Path annotated class {}", clazz.getName());
}
refreshClass(classLoader, clazz.getName(), null, 500);
}
}
private void refreshClass(ClassLoader classLoader, String name, Class<?> original, int timeout) {<FILL_FUNCTION_BODY>}
@Init
public void initializeInstance(PluginConfiguration pluginConfiguration) {
LOGGER.info("ResteasyRegistry plugin initializing");
}
}
|
try {
Class<?> cmdClass = Class.forName(RefreshRegistryCommand.class.getName(), true, appClassLoader);
Command cmd = (Command) cmdClass.newInstance();
ReflectionHelper.invoke(cmd, cmdClass, "setupCmd",
new Class[] { ClassLoader.class, Object.class, Object.class, String.class, java.lang.Class.class },
classLoader, servletContext, servletContainerDispatcher, name, original);
scheduler.scheduleCommand(cmd, timeout);
} catch (Exception e) {
LOGGER.error("refreshClass() exception {}.", e.getMessage());
}
| 1,379
| 160
| 1,539
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/SpringBootPlugin.java
|
SpringBootPlugin
|
register
|
class SpringBootPlugin {
private static final AgentLogger LOGGER = AgentLogger.getLogger(SpringBootPlugin.class);
@Init
Scheduler scheduler;
@Init
ClassLoader appClassLoader;
private final AtomicBoolean isInit = new AtomicBoolean(false);
public void init() {
if (isInit.compareAndSet(false, true)) {
LOGGER.info("Spring Boot plugin initialized");
}
}
public void init(String version) throws ClassNotFoundException {
if (isInit.compareAndSet(false, true)) {
LOGGER.info("Spring Boot plugin initialized - Spring Boot core version '{}'", version);
}
}
@OnClassLoadEvent(classNameRegexp = "org.springframework.boot.SpringApplication")
public static void register(ClassLoader appClassLoader, CtClass clazz, ClassPool classPool) throws
CannotCompileException, NotFoundException {<FILL_FUNCTION_BODY>}
}
|
StringBuilder src = new StringBuilder("{");
// init a spring plugin with every appclassloader
src.append(PluginManagerInvoker.buildInitializePlugin(SpringBootPlugin.class));
src.append(PluginManagerInvoker.buildCallPluginMethod(SpringBootPlugin.class, "init",
"org.springframework.boot.SpringBootVersion.getVersion()", String.class.getName()));
src.append("}");
for (CtConstructor constructor : clazz.getDeclaredConstructors()) {
constructor.insertBeforeBody(src.toString());
}
CtMethod method = clazz.getDeclaredMethod("createApplicationContext");
method.insertAfter(
"{org.hotswap.agent.plugin.spring.boot.listener.PropertySourceChangeListener.register($_);}");
| 252
| 203
| 455
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/env/HotswapSpringProperties.java
|
HotswapSpringProperties
|
update
|
class HotswapSpringProperties extends Properties implements HotswapSpringPropertiesReloader<Properties> {
public HotswapSpringProperties() {
super();
}
public HotswapSpringProperties(Properties properties) {
super();
this.putAll(properties);
}
@Override
public void update(Properties newValue) {<FILL_FUNCTION_BODY>}
@Override
public Properties get() {
return this;
}
}
|
if (newValue == null || newValue.isEmpty()) {
this.clear();
return;
}
this.clear();
this.putAll(newValue);
| 129
| 47
| 176
|
<methods>public void <init>() ,public void <init>(int) ,public void <init>(java.util.Properties) ,public synchronized void clear() ,public synchronized java.lang.Object clone() ,public synchronized java.lang.Object compute(java.lang.Object, BiFunction<? super java.lang.Object,? super java.lang.Object,?>) ,public synchronized java.lang.Object computeIfAbsent(java.lang.Object, Function<? super java.lang.Object,?>) ,public synchronized java.lang.Object computeIfPresent(java.lang.Object, BiFunction<? super java.lang.Object,? super java.lang.Object,?>) ,public boolean contains(java.lang.Object) ,public boolean containsKey(java.lang.Object) ,public boolean containsValue(java.lang.Object) ,public Enumeration<java.lang.Object> elements() ,public Set<Entry<java.lang.Object,java.lang.Object>> entrySet() ,public synchronized boolean equals(java.lang.Object) ,public synchronized void forEach(BiConsumer<? super java.lang.Object,? super java.lang.Object>) ,public java.lang.Object get(java.lang.Object) ,public java.lang.Object getOrDefault(java.lang.Object, java.lang.Object) ,public java.lang.String getProperty(java.lang.String) ,public java.lang.String getProperty(java.lang.String, java.lang.String) ,public synchronized int hashCode() ,public boolean isEmpty() ,public Set<java.lang.Object> keySet() ,public Enumeration<java.lang.Object> keys() ,public void list(java.io.PrintStream) ,public void list(java.io.PrintWriter) ,public synchronized void load(java.io.Reader) throws java.io.IOException,public synchronized void load(java.io.InputStream) throws java.io.IOException,public synchronized void loadFromXML(java.io.InputStream) throws java.io.IOException, java.util.InvalidPropertiesFormatException,public synchronized java.lang.Object merge(java.lang.Object, java.lang.Object, BiFunction<? super java.lang.Object,? super java.lang.Object,?>) ,public Enumeration<?> propertyNames() ,public synchronized java.lang.Object put(java.lang.Object, java.lang.Object) ,public synchronized void putAll(Map<?,?>) ,public synchronized java.lang.Object putIfAbsent(java.lang.Object, java.lang.Object) ,public synchronized java.lang.Object remove(java.lang.Object) ,public synchronized boolean remove(java.lang.Object, java.lang.Object) ,public synchronized java.lang.Object replace(java.lang.Object, java.lang.Object) ,public synchronized boolean replace(java.lang.Object, java.lang.Object, java.lang.Object) ,public synchronized void replaceAll(BiFunction<? super java.lang.Object,? super java.lang.Object,?>) ,public void save(java.io.OutputStream, java.lang.String) ,public synchronized java.lang.Object setProperty(java.lang.String, java.lang.String) ,public int size() ,public void store(java.io.Writer, java.lang.String) throws java.io.IOException,public void store(java.io.OutputStream, java.lang.String) throws java.io.IOException,public void storeToXML(java.io.OutputStream, java.lang.String) throws java.io.IOException,public void storeToXML(java.io.OutputStream, java.lang.String, java.lang.String) throws java.io.IOException,public void storeToXML(java.io.OutputStream, java.lang.String, java.nio.charset.Charset) throws java.io.IOException,public Set<java.lang.String> stringPropertyNames() ,public synchronized java.lang.String toString() ,public Collection<java.lang.Object> values() <variables>private static final jdk.internal.misc.Unsafe UNSAFE,protected volatile java.util.Properties defaults,private volatile transient ConcurrentHashMap<java.lang.Object,java.lang.Object> map,private static final long serialVersionUID
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/env/HotswapSpringReloadMap.java
|
HotswapSpringReloadMap
|
update
|
class HotswapSpringReloadMap<K, V> implements Map<K, V>, HotswapSpringPropertiesReloader<Map<K, V>> {
private Map<K, V> value;
public HotswapSpringReloadMap(Map<K, V> value) {
this.value = value;
}
public HotswapSpringReloadMap() {
this.value = new HashMap<>();
}
@Override
public int size() {
return this.value.size();
}
@Override
public boolean isEmpty() {
return this.value.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return this.value.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return this.value.containsValue(value);
}
@Override
public V get(Object key) {
return this.value.get(key);
}
@Override
public V put(K key, V value) {
throw new UnsupportedOperationException("put is not supported");
}
@Override
public V remove(Object key) {
throw new UnsupportedOperationException("put is not supported");
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
throw new UnsupportedOperationException("put is not supported");
}
@Override
public void clear() {
throw new UnsupportedOperationException("put is not supported");
}
@Override
public Set<K> keySet() {
return this.value.keySet();
}
@Override
public Collection<V> values() {
return this.value.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return this.value.entrySet();
}
@SuppressWarnings("unchecked")
@Override
public void update(Map<K, V> newValue) {<FILL_FUNCTION_BODY>}
@Override
public Map<K, V> get() {
return this;
}
}
|
if (newValue == null || newValue.isEmpty()) {
this.value = (newValue == null ? Collections.EMPTY_MAP : newValue);
return;
}
this.value = newValue;
| 555
| 58
| 613
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/env/ListPropertySourceReloader.java
|
ListPropertySourceReloader
|
update
|
class ListPropertySourceReloader<T> implements HotswapSpringPropertiesReloader<List<Map<String, T>>> {
private static AgentLogger LOGGER = AgentLogger.getLogger(ListPropertySourceReloader.class);
protected final String name;
protected final Resource resource;
protected List<Map<String, T>> hotswapMapList;
public ListPropertySourceReloader(String name, Resource resource) {
this.name = name;
this.resource = resource;
}
Map<String, T> createMap(Map map) {
return new HotswapSpringReloadMap<>(map);
}
void updateItemValue(Map hotswapMap, Map newHotswapMap) {
if (hotswapMap instanceof HotswapSpringReloadMap) {
((HotswapSpringReloadMap) hotswapMap).update(newHotswapMap);
}
}
@Override
public void update(List<Map<String, T>> newValue) {<FILL_FUNCTION_BODY>}
@Override
public List<Map<String, T>> get() {
return hotswapMapList;
}
}
|
if (newValue == null || newValue.isEmpty()) {
hotswapMapList = (newValue == null ? Collections.emptyList() : newValue);
return;
}
if (hotswapMapList == null) {
synchronized (this) {
if (hotswapMapList == null) {
hotswapMapList = new ArrayList<>(newValue.size());
for (Map<String, ?> map : newValue) {
hotswapMapList.add(createMap(map));
}
return;
}
}
}
for (int i = 0; i < hotswapMapList.size(); i++) {
Map<String, ?> hotswapMap = hotswapMapList.get(i);
Map<String, ?> newHotswapMap = newValue.get(i);
updateItemValue(hotswapMap, newHotswapMap);
}
| 311
| 245
| 556
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/env/v1/PropertiesPropertySourceLoader.java
|
PropertiesPropertySourceLoader
|
doLoad
|
class PropertiesPropertySourceLoader extends BasePropertiesPropertySourceLoader<Properties> {
private static AgentLogger LOGGER = AgentLogger.getLogger(PropertiesPropertySourceLoader.class);
final String name;
final Resource resource;
final String profile;
public PropertiesPropertySourceLoader(String name, Resource resource, String profile) {
super(new HotswapSpringProperties());
this.name = name;
this.resource = resource;
this.profile = profile;
}
protected Properties doLoad() {<FILL_FUNCTION_BODY>}
}
|
try {
Class clazz = Class.forName("org.springframework.core.io.support.PropertiesLoaderUtils");
return (Properties) ReflectionHelper.invoke(null, clazz, "loadProperties",
new Class[]{Resource.class}, resource);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
| 139
| 87
| 226
|
<methods>public void <init>(HotswapSpringPropertiesReloader<java.util.Properties>) ,public final java.util.Properties load() ,public final void reload() <variables>protected HotswapSpringPropertiesReloader<java.util.Properties> properties
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/env/v1/YamlPropertySourceLoader.java
|
YamlPropertySourceLoader
|
doLoad
|
class YamlPropertySourceLoader extends BasePropertiesPropertySourceLoader<Map<String, Object>> {
private static AgentLogger LOGGER = AgentLogger.getLogger(YamlPropertySourceLoader.class);
final String profile;
final Resource resource;
public YamlPropertySourceLoader(String name, Resource resource, String profile) {
super(new HotswapSpringReloadMap());
this.profile = profile;
this.resource = resource;
}
protected Map<String, Object> doLoad() {<FILL_FUNCTION_BODY>}
}
|
try {
Object target = ReflectionHelper.invokeConstructor("org.springframework.boot.env.YamlPropertySourceLoader$Processor",
this.getClass().getClassLoader(), new Class[]{Resource.class, String.class}, resource, profile);
return (Map<String, Object>) ReflectionHelper.invoke(target, "process");
} catch (Exception e) {
throw new RuntimeException(e);
}
| 140
| 104
| 244
|
<methods>public void <init>(HotswapSpringPropertiesReloader<Map<java.lang.String,java.lang.Object>>) ,public final Map<java.lang.String,java.lang.Object> load() ,public final void reload() <variables>protected HotswapSpringPropertiesReloader<Map<java.lang.String,java.lang.Object>> properties
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/env/v2/LowVersionPropertiesPropertySourceLoader.java
|
LowVersionPropertiesPropertySourceLoader
|
doLoad
|
class LowVersionPropertiesPropertySourceLoader extends BasePropertiesPropertySourceLoader<Map<String, ?>> {
private static AgentLogger LOGGER = AgentLogger.getLogger(LowVersionPropertiesPropertySourceLoader.class);
private PropertiesPropertySourceLoader propertiesPropertySourceLoader;
private HotswapSpringReloadMap hotswapSpringReloadMap;
private Resource resource;
public LowVersionPropertiesPropertySourceLoader(PropertiesPropertySourceLoader propertiesPropertySourceLoader,
String name, Resource resource) {
super(new HotswapSpringReloadMap());
this.propertiesPropertySourceLoader = propertiesPropertySourceLoader;
this.resource = resource;
}
/**
* spring boot 2.0 lower version
*
* @return
*/
protected Map<String, ?> doLoad() {<FILL_FUNCTION_BODY>}
}
|
return (Map<String, ?>) ReflectionHelper.invoke(propertiesPropertySourceLoader, PropertiesPropertySourceLoader.class,
"loadProperties", new Class[]{Resource.class}, resource);
| 212
| 47
| 259
|
<methods>public void <init>(HotswapSpringPropertiesReloader<Map<java.lang.String,?>>) ,public final Map<java.lang.String,?> load() ,public final void reload() <variables>protected HotswapSpringPropertiesReloader<Map<java.lang.String,?>> properties
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/env/v2/PropertiesPropertySourceLoader.java
|
PropertiesPropertySourceLoader
|
doLoad
|
class PropertiesPropertySourceLoader extends BasePropertiesPropertySourceLoader<List<Map<String, ?>>> {
private static AgentLogger LOGGER = AgentLogger.getLogger(PropertiesPropertySourceLoader.class);
private org.springframework.boot.env.PropertiesPropertySourceLoader propertiesPropertySourceLoader;
private Resource resource;
public PropertiesPropertySourceLoader(
org.springframework.boot.env.PropertiesPropertySourceLoader propertiesPropertySourceLoader,
String name, Resource resource) {
super(new ListPropertySourceReloader(name, resource));
this.propertiesPropertySourceLoader = propertiesPropertySourceLoader;
this.resource = resource;
}
/**
* spring boot 2.x higher version
*
* @return
*/
protected List<Map<String, ?>> doLoad() {<FILL_FUNCTION_BODY>}
}
|
return (List<Map<String, ?>>) ReflectionHelper.invoke(propertiesPropertySourceLoader, org.springframework.boot.env.PropertiesPropertySourceLoader.class,
"loadProperties", new Class[]{Resource.class}, resource);
| 207
| 57
| 264
|
<methods>public void <init>(HotswapSpringPropertiesReloader<List<Map<java.lang.String,?>>>) ,public final List<Map<java.lang.String,?>> load() ,public final void reload() <variables>protected HotswapSpringPropertiesReloader<List<Map<java.lang.String,?>>> properties
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/env/v2/YamlPropertySourceLoader.java
|
YamlPropertySourceLoader
|
doLoad
|
class YamlPropertySourceLoader extends BasePropertiesPropertySourceLoader<List<Map<String, Object>>> {
private static AgentLogger LOGGER = AgentLogger.getLogger(YamlPropertySourceLoader.class);
private Resource resource;
public YamlPropertySourceLoader(String name, Resource resource) {
super(new ListPropertySourceReloader(name, resource));
this.resource = resource;
}
protected List<Map<String, Object>> doLoad() {<FILL_FUNCTION_BODY>}
}
|
try {
Object yamlLoader = ReflectionHelper.invokeConstructor(
"org.springframework.boot.env.OriginTrackedYamlLoader",
this.getClass().getClassLoader(), new Class[]{Resource.class}, resource);
return (List<Map<String, Object>>) ReflectionHelper.invoke(yamlLoader, "load");
} catch (Exception e) {
LOGGER.error("load yaml error, resource: {}", e, resource);
}
return null;
| 128
| 122
| 250
|
<methods>public void <init>(HotswapSpringPropertiesReloader<List<Map<java.lang.String,java.lang.Object>>>) ,public final List<Map<java.lang.String,java.lang.Object>> load() ,public final void reload() <variables>protected HotswapSpringPropertiesReloader<List<Map<java.lang.String,java.lang.Object>>> properties
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/listener/PropertySourceChangeListener.java
|
PropertySourceChangeListener
|
equals
|
class PropertySourceChangeListener implements SpringListener<SpringEvent<?>> {
private final static AgentLogger LOGGER = AgentLogger.getLogger(PropertySourceChangeListener.class);
private final DefaultListableBeanFactory beanFactory;
public static void register(ConfigurableApplicationContext context) {
ConfigurableListableBeanFactory configurableListableBeanFactory = context.getBeanFactory();
if (!(configurableListableBeanFactory instanceof DefaultListableBeanFactory)) {
LOGGER.debug(
"beanFactory is not DefaultListableBeanFactory, skip register PropertySourceChangeBootListener, {}",
ObjectUtils.identityToString(configurableListableBeanFactory));
return;
}
LOGGER.debug("register PropertySourceChangeBootListener, {}",
ObjectUtils.identityToString(configurableListableBeanFactory));
PropertySourceChangeListener propertySourceChangeListener = new PropertySourceChangeListener(
(DefaultListableBeanFactory)configurableListableBeanFactory);
// add instance to map and instance
SpringEventSource.INSTANCE.addListener(propertySourceChangeListener);
}
public PropertySourceChangeListener(DefaultListableBeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Override
public DefaultListableBeanFactory beanFactory() {
return beanFactory;
}
@Override
public void onEvent(SpringEvent<?> event) {
if (event instanceof PropertiesChangeEvent) {
refreshConfigurationProperties(event.getBeanFactory());
}
}
private void refreshConfigurationProperties(ConfigurableListableBeanFactory eventBeanFactory) {
for (String singleton : beanFactory.getSingletonNames()) {
Object bean = beanFactory.getSingleton(singleton);
Class<?> beanClass = ClassUtils.getUserClass(bean.getClass());
if (AnnotationHelper.hasAnnotation(beanClass, ConfigurationProperties.class.getName())) {
LOGGER.debug("refresh configuration properties: {}", beanClass);
String[] beanNames = beanFactory.getBeanNamesForType(beanClass);
if (beanNames != null && beanNames.length > 0) {
SpringEventSource.INSTANCE.fireEvent(new BeanChangeEvent(beanNames, eventBeanFactory));
}
}
}
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return Objects.hash(beanFactory);
}
}
|
if (this == o) {return true;}
if (!(o instanceof PropertySourceChangeListener)) {return false;}
PropertySourceChangeListener that = (PropertySourceChangeListener)o;
return Objects.equals(beanFactory, that.beanFactory);
| 603
| 63
| 666
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-boot-plugin/src/main/java/org/hotswap/agent/plugin/spring/boot/transformers/PropertySourceTransformer.java
|
PropertySourceTransformer
|
transformPropertySource
|
class PropertySourceTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(PropertySourceTransformer.class);
@OnClassLoadEvent(classNameRegexp = "org.springframework.core.env.MapPropertySource")
public static void transformMapPropertySource(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {
transformPropertySource(clazz, classPool);
LOGGER.debug("Patch org.springframework.boot.env.MapPropertySource success");
}
@OnClassLoadEvent(classNameRegexp= "org.springframework.boot.env.OriginTrackedMapPropertySource")
public static void transformOriginTrackedMapPropertySource(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {
transformPropertySource(clazz, classPool);
LOGGER.debug("Patch org.springframework.boot.env.OriginTrackedMapPropertySource success");
}
private static void transformPropertySource(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
clazz.addInterface(classPool.get("org.hotswap.agent.plugin.spring.transformers.api.ReloadablePropertySource"));
clazz.addField(CtField.make("private org.hotswap.agent.plugin.spring.api.PropertySourceReloader reload;", clazz));
clazz.addMethod(CtMethod.make("public void setReload(org.hotswap.agent.plugin.spring.api.PropertySourceReloader r) { this.reload = r; }", clazz));
clazz.addMethod(CtMethod.make("public void reload() { if (this.reload != null) {this.reload.reload();} }", clazz));
| 274
| 183
| 457
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/SpringBeanClassFileTransformer.java
|
SpringBeanClassFileTransformer
|
transform
|
class SpringBeanClassFileTransformer implements HaClassFileTransformer {
private ClassLoader appClassLoader;
private Scheduler scheduler;
private String basePackage;
public SpringBeanClassFileTransformer(ClassLoader appClassLoader, Scheduler scheduler, String basePackage) {
this.appClassLoader = appClassLoader;
this.scheduler = scheduler;
this.basePackage = basePackage;
}
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
ProtectionDomain protectionDomain,
byte[] classfileBuffer) {<FILL_FUNCTION_BODY>}
@Override
public boolean isForRedefinitionOnly() {
return true;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
SpringBeanClassFileTransformer that = (SpringBeanClassFileTransformer) o;
return Objects.equals(appClassLoader, that.appClassLoader) && Objects.equals(basePackage, that.basePackage);
}
@Override
public int hashCode() {
return Objects.hash(appClassLoader, basePackage);
}
}
|
if (classBeingRedefined != null) {
SpringChangesAnalyzer analyzer = new SpringChangesAnalyzer(appClassLoader);
if (analyzer.isReloadNeeded(classBeingRedefined, classfileBuffer)) {
scheduler.scheduleCommand(new ClassPathBeanRefreshCommand(classBeingRedefined.getClassLoader(),
basePackage, className, classfileBuffer, scheduler));
}
}
return classfileBuffer;
| 321
| 116
| 437
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/SpringChangesAnalyzer.java
|
SpringChangesAnalyzer
|
isSyntheticClass
|
class SpringChangesAnalyzer {
private static AgentLogger LOGGER = AgentLogger.getLogger(SpringPlugin.class);
private ClassPool cp;
public SpringChangesAnalyzer(final ClassLoader classLoader) {
this.cp = new ClassPool() {
@Override
public ClassLoader getClassLoader() {
return classLoader;
}
};
cp.appendSystemPath();
cp.appendClassPath(new LoaderClassPath(classLoader));
}
public boolean isReloadNeeded(Class<?> classBeingRedefined, byte[] classfileBuffer) {
if (classBeingRedefined.isSynthetic() || isSyntheticClass(classBeingRedefined))
return false;
return classChangeNeedsReload(classBeingRedefined, classfileBuffer);
}
private boolean classChangeNeedsReload(Class<?> classBeingRedefined, byte[] classfileBuffer) {
CtClass makeClass = null;
try {
makeClass = cp.makeClass(new java.io.ByteArrayInputStream(classfileBuffer));
return ClassSignatureComparer.isPoolClassDifferent(classBeingRedefined, cp);
} catch (Exception e) {
LOGGER.error("Error analyzing class {} for reload necessity. Defaulting to yes.", e,
classBeingRedefined.getName());
} finally {
if (makeClass != null) {
makeClass.detach();
}
}
return true;
}
protected boolean isSyntheticClass(Class<?> classBeingRedefined) {<FILL_FUNCTION_BODY>}
}
|
return classBeingRedefined.getSimpleName().contains("$$_javassist")
|| classBeingRedefined.getName().startsWith("com.sun.proxy.$Proxy")
|| classBeingRedefined.getSimpleName().contains("$$Enhancer")
|| classBeingRedefined.getSimpleName().contains("$$_jvst") // javassist proxy
|| classBeingRedefined.getSimpleName().contains("$HibernateProxy$")
;
| 409
| 119
| 528
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/AutowiredAnnotationProcessor.java
|
AutowiredAnnotationProcessor
|
processSingletonBeanInjection
|
class AutowiredAnnotationProcessor {
private static AgentLogger LOGGER = AgentLogger.getLogger(AutowiredAnnotationProcessor.class);
public static void processSingletonBeanInjection(DefaultListableBeanFactory beanFactory) {<FILL_FUNCTION_BODY>}
}
|
try {
Map<String, AutowiredAnnotationBeanPostProcessor> postProcessors = beanFactory.getBeansOfType(
AutowiredAnnotationBeanPostProcessor.class);
if (postProcessors.isEmpty()) {
LOGGER.debug("AutowiredAnnotationProcessor not exist");
return;
}
AutowiredAnnotationBeanPostProcessor postProcessor = postProcessors.values().iterator().next();
boolean postProcessPropertyValuesNotExists = false;
for (String beanName : beanFactory.getBeanDefinitionNames()) {
Object object = beanFactory.getSingleton(beanName);
if (object != null) {
if (postProcessPropertyValuesNotExists) {
// spring 6.x
postProcessor.postProcessProperties(null, object, beanName);
continue;
}
try {
// from spring 3.2.x to 5.x
postProcessor.postProcessPropertyValues(null, null, object, beanName);
} catch (NoSuchMethodError e) {
// spring 6.x
postProcessor.postProcessProperties(null, object, beanName);
postProcessPropertyValuesNotExists = true;
}
}
}
} catch (Throwable e) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("AutowiredAnnotationProcessor maybe not exist", e);
} else {
LOGGER.warning("AutowiredAnnotationProcessor maybe not exist : " + e.getMessage());
}
}
| 68
| 366
| 434
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/BeanDefinitionProcessor.java
|
BeanDefinitionProcessor
|
registerBeanDefinition
|
class BeanDefinitionProcessor {
private static final AgentLogger LOGGER = AgentLogger.getLogger(BeanDefinitionProcessor.class);
public static void registerBeanDefinition(DefaultListableBeanFactory defaultListableBeanFactory, String beanName, BeanDefinition beanDefinition) {<FILL_FUNCTION_BODY>}
public static void removeBeanDefinition(DefaultListableBeanFactory defaultListableBeanFactory, String beanName) {
LOGGER.debug("remove BeanDefinition '{}' from '{}'", beanName,
ObjectUtils.identityToString(defaultListableBeanFactory));
}
}
|
LOGGER.debug("register new BeanDefinition '{}' into '{}'", beanName,
ObjectUtils.identityToString(defaultListableBeanFactory));
org.hotswap.agent.plugin.spring.files.XmlBeanDefinitionScannerAgent.registerBean(beanName, beanDefinition);
| 141
| 73
| 214
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/BeanFactoryProcessor.java
|
BeanFactoryProcessor
|
isAllowBeanDefinitionOverriding
|
class BeanFactoryProcessor {
private static AgentLogger LOGGER = AgentLogger.getLogger(BeanFactoryProcessor.class);
public static void removeBeanDefinition(DefaultListableBeanFactory beanFactory, String beanName) {
resetEmbeddedValueResolvers(beanFactory, beanName);
beanFactory.removeBeanDefinition(beanName);
}
public static void destroySingleton(DefaultListableBeanFactory beanFactory, String beanName) {
// remove embeddedValueResolvers cache in PlaceholderConfigurerSupport
resetEmbeddedValueResolvers(beanFactory, beanName);
beanFactory.destroySingleton(beanName);
}
/**
* invoked by @see org.hotswap.agent.plugin.spring.transformers.BeanFactoryTransformer
* @param beanFactory
* @param beanName
*/
public static void postProcessDestroySingleton(DefaultSingletonBeanRegistry beanFactory, String beanName) {
// check if reload , then log
if (beanFactory instanceof ConfigurableListableBeanFactory &&
BeanFactoryAssistant.getBeanFactoryAssistant((ConfigurableListableBeanFactory)beanFactory).isReload()) {
LOGGER.info("destroy bean '{}' from '{}'", beanName, ObjectUtils.identityToString(beanFactory));
}
if (beanFactory instanceof BeanFactoryLifecycle) {
((BeanFactoryLifecycle)beanFactory).hotswapAgent$destroyBean(beanName);
}
}
/**
* invoked by @see org.hotswap.agent.plugin.spring.transformers.BeanFactoryTransformer
*
* @param beanFactory
* @param beanName
*/
public static void postProcessCreateBean(AbstractAutowireCapableBeanFactory beanFactory, String beanName,
RootBeanDefinition mbd) {
// check if reload , then log
if (beanFactory instanceof ConfigurableListableBeanFactory
&& BeanFactoryAssistant.getBeanFactoryAssistant((ConfigurableListableBeanFactory)beanFactory).isReload()
&& mbd.isSingleton()) {
LOGGER.info("create new singleton bean '{}' from '{}'", beanName,
ObjectUtils.identityToString(beanFactory));
}
}
public static boolean needReloadOnConstructor(DefaultListableBeanFactory beanFactory, AbstractBeanDefinition currentBeanDefinition,
String beanName, Predicate<Constructor<?>[]> predicate) {
Constructor<?>[] constructors = determineConstructors(beanFactory, beanName);
if (constructors != null && constructors.length > 0) {
return predicate.test(constructors);
}
return false;
}
private static Constructor<?>[] determineConstructors(DefaultListableBeanFactory beanFactory, String beanName) {
Class<?> beanClass = resolveBeanClass(beanFactory, beanName);
if (beanClass == null) {
return null;
}
Method method = ReflectionUtils.findMethod(beanFactory.getClass(), "determineConstructorsFromBeanPostProcessors", Class.class, String.class);
if (method == null) {
return null;
}
try {
method.setAccessible(true);
return (Constructor<?>[]) method.invoke(beanFactory, beanClass, beanName);
} catch (Exception e) {
LOGGER.error("determineConstructorsFromBeanPostProcessors error", e);
}
return null;
}
private static Class<?> resolveBeanClass(DefaultListableBeanFactory beanFactory, String beanName) {
Method resolveBeanClassMethod = ReflectionUtils.findMethod(beanFactory.getClass(), "resolveBeanClass", RootBeanDefinition.class, String.class, Class[].class);
if (resolveBeanClassMethod != null) {
resolveBeanClassMethod.setAccessible(true);
Class<?> beanClass = null;
BeanDefinition rBeanDefinition = beanFactory.getMergedBeanDefinition(beanName);
try {
if (rBeanDefinition != null) {
beanClass = (Class<?>) resolveBeanClassMethod.invoke(beanFactory, rBeanDefinition, beanName, new Class[]{});
}
return beanClass;
} catch (Exception e) {
LOGGER.warning("resolveBeanClass error", e);
}
}
return null;
}
private static void resetEmbeddedValueResolvers(DefaultListableBeanFactory beanFactory, String beanName) {
Object target = beanFactory.getSingleton(beanName);
if (target != null && target instanceof PlaceholderConfigurerSupport && target instanceof ValueResolverSupport) {
ValueResolverSupport placeholderConfigurerSupport = (ValueResolverSupport) target;
Field field = ReflectionUtils.findField(beanFactory.getClass(), "embeddedValueResolvers");
if (field != null) {
ReflectionUtils.makeAccessible(field);
List<StringValueResolver> embeddedValueResolvers = ReflectionUtils.getField(field, beanFactory);
embeddedValueResolvers.removeAll(placeholderConfigurerSupport.valueResolvers());
}
}
}
public static boolean isAllowBeanDefinitionOverriding(DefaultListableBeanFactory beanFactory) {<FILL_FUNCTION_BODY>}
public static void setAllowBeanDefinitionOverriding(DefaultListableBeanFactory beanFactory, boolean allowEagerClassLoading) {
beanFactory.setAllowBeanDefinitionOverriding(allowEagerClassLoading);
}
public static BeanDefinition getBeanDefinition(ConfigurableListableBeanFactory beanFactory, String beanName) {
if (beanName.startsWith("&")) {
beanName = beanName.substring(1);
}
return beanFactory.getBeanDefinition(beanName);
}
}
|
// org.springframework.beans.factory.support.DefaultListableBeanFactory.isAllowBeanDefinitionOverriding is introduced in spring 4.1.2
Object target = ReflectionHelper.getNoException(beanFactory, beanFactory.getClass(), "allowBeanDefinitionOverriding");
if (target == null) {
return false;
}
return (boolean) target;
| 1,422
| 94
| 1,516
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/ConfigurationClassPostProcessorEnhance.java
|
ConfigurationClassPostProcessorEnhance
|
postProcess
|
class ConfigurationClassPostProcessorEnhance {
private static final AgentLogger LOGGER = AgentLogger.getLogger(ConfigurationClassPostProcessorEnhance.class);
private static final Map<BeanDefinitionRegistry,ConfigurationClassPostProcessorEnhance> INSTANCES = new ConcurrentHashMap<>(4);
private static final String CONFIGURATION_CLASS_ATTRIBUTE =
Conventions.getQualifiedAttributeName(ConfigurationClassPostProcessor.class, "configurationClass");
private volatile ConfigurationClassPostProcessor processor;
public static ConfigurationClassPostProcessorEnhance getInstance(BeanDefinitionRegistry registry) {
ConfigurationClassPostProcessorEnhance result = INSTANCES.putIfAbsent(registry, new ConfigurationClassPostProcessorEnhance());
if (result == null) {
result = INSTANCES.get(registry);
}
return result;
}
private ConfigurationClassPostProcessorEnhance() {
}
public void setProcessor(ConfigurationClassPostProcessor processor) {
LOGGER.trace("ConfigurationClassPostProcessorAgent.setProcessor({})", processor);
this.processor = processor;
}
public ConfigurationClassPostProcessor getProcessor() {
return processor;
}
public void resetConfigurationClassPostProcessor(BeanDefinitionRegistry registry) {
LOGGER.trace("ConfigurationClassPostProcessorAgent.resetConfigurationClassPostProcessor({})");
if (processor == null) {
return;
}
resetCachingMetadataReaderFactoryCache();
resetBeanNameCache();
resetBeanFactoryCache(registry);
}
public void postProcess(BeanDefinitionRegistry registry, String beanName) {
if (processor == null) {
return;
}
resetCachingMetadataReaderFactoryCache();
resetBeanNameCache();
resetBeanFactoryCache(registry);
removeBeanAttribute(registry, beanName);
processor.processConfigBeanDefinitions(registry);
}
public void postProcess(BeanDefinitionRegistry registry) {<FILL_FUNCTION_BODY>}
private MetadataReaderFactory getMetadataReaderFactory() {
return (MetadataReaderFactory) ReflectionHelper.getNoException(processor, ConfigurationClassPostProcessor.class,
"metadataReaderFactory");
}
private void resetCachingMetadataReaderFactoryCache() {
LOGGER.trace("Clearing MetadataReaderFactory cache");
MetadataReaderFactory metadataReaderFactory = getMetadataReaderFactory();
if (metadataReaderFactory != null) {
try {
ReflectionHelper.invoke(metadataReaderFactory, "clearCache");
} catch (Exception e) {
LOGGER.debug("Unable to clear MetadataReaderFactory cache");
}
}
}
private void resetBeanFactoryCache(BeanDefinitionRegistry registry) {
LOGGER.trace("Clearing BeanFactory cache");
DefaultListableBeanFactory beanFactory = RegistryUtils.maybeRegistryToBeanFactory(registry);
if (beanFactory == null) {
return;
}
beanFactory.setAllowBeanDefinitionOverriding(true);
resetFactoryMethodCandidateCache(beanFactory);
}
private void removeBeanAttribute(BeanDefinitionRegistry registry, String beanName) {
BeanDefinition bd = registry.getBeanDefinition(beanName);
if (bd.hasAttribute(CONFIGURATION_CLASS_ATTRIBUTE)) {
LOGGER.trace("Removing attribute '{}' from bean definition '{}'", CONFIGURATION_CLASS_ATTRIBUTE, beanName);
bd.removeAttribute(CONFIGURATION_CLASS_ATTRIBUTE);
}
}
private void resetFactoryMethodCandidateCache(DefaultListableBeanFactory factory) {
Map<Class<?>, Method[]> cache = (Map<Class<?>, Method[]>) ReflectionHelper.getNoException(factory,
AbstractAutowireCapableBeanFactory.class, "factoryMethodCandidateCache");
if (cache != null) {
LOGGER.trace("Cache cleared: AbstractAutowireCapableBeanFactory.factoryMethodCandidateCache");
cache.clear();
}
}
private void resetBeanNameCache() {
Map<Method, String> cache = (Map<Method, String>) ReflectionHelper.getNoException(null,
"org.springframework.context.annotation.BeanAnnotationHelper",
processor.getClass().getClassLoader(), "beanNameCache");
if (cache != null) {
LOGGER.trace("Cache cleared: BeanAnnotationHelper.beanNameCache");
cache.clear();
}
}
}
|
LOGGER.trace("ConfigurationClassPostProcessorAgent.postProcess({})", ObjectUtils.identityToString(registry));
if (processor == null) {
return;
}
resetCachingMetadataReaderFactoryCache();
resetBeanNameCache();
resetBeanFactoryCache(registry);
processor.processConfigBeanDefinitions(registry);
| 1,109
| 89
| 1,198
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/ResetAnnotationCache.java
|
ResetAnnotationCache
|
resetAnnotationScanner
|
class ResetAnnotationCache {
private static AgentLogger LOGGER = AgentLogger.getLogger(ResetAnnotationCache.class);
/**
* Reset Spring annotation scanner.
* @since 5.x
*/
public static void resetAnnotationScanner(DefaultListableBeanFactory defaultListableBeanFactory) {<FILL_FUNCTION_BODY>}
}
|
Map<Method, String> declaredAnnotationCache = (Map<Method, String>) ReflectionHelper.getNoException(null,
"org.springframework.core.annotation.AnnotationsScanner",
defaultListableBeanFactory.getClass().getClassLoader(), "declaredAnnotationCache");
if (declaredAnnotationCache != null) {
LOGGER.trace("Cache cleared: AnnotationsScanner.beanNameCache");
declaredAnnotationCache.clear();
}
Map<Method, String> baseTypeMethodsCache = (Map<Method, String>) ReflectionHelper.getNoException(null,
"org.springframework.core.annotation.AnnotationsScanner",
defaultListableBeanFactory.getClass().getClassLoader(), "baseTypeMethodsCache");
if (baseTypeMethodsCache != null) {
LOGGER.trace("Cache cleared: BeanAnnotationHelper.baseTypeMethodsCache");
baseTypeMethodsCache.clear();
}
| 90
| 227
| 317
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/ResetBeanFactoryPostProcessorCaches.java
|
ResetBeanFactoryPostProcessorCaches
|
clearSetFieldOfConfigurationClassPostProcessor
|
class ResetBeanFactoryPostProcessorCaches {
private static final AgentLogger LOGGER = AgentLogger.getLogger(ResetBeanFactoryPostProcessorCaches.class);
public static void reset(DefaultListableBeanFactory beanFactory) {
resetConfigurationClassPostProcessorCache(beanFactory);
}
private static void resetConfigurationClassPostProcessorCache(DefaultListableBeanFactory beanFactory) {
LOGGER.trace("Resetting ConfigurationClassPostProcessor caches");
int factoryId = System.identityHashCode(beanFactory);
try {
ConfigurationClassPostProcessor ccpp = beanFactory.getBean(ConfigurationClassPostProcessor.class);
clearSetFieldOfConfigurationClassPostProcessor(ccpp, "factoriesPostProcessed", factoryId);
clearSetFieldOfConfigurationClassPostProcessor(ccpp, "registriesPostProcessed", factoryId);
} catch (NoSuchBeanDefinitionException e) {
LOGGER.trace("ConfigurationClassPostProcessor bean doesn't present");
}
}
private static void clearSetFieldOfConfigurationClassPostProcessor(ConfigurationClassPostProcessor ccpp,
String fieldName, int factoryId) {<FILL_FUNCTION_BODY>}
}
|
try {
Field field = ConfigurationClassPostProcessor.class.getDeclaredField(fieldName);
field.setAccessible(true);
Set<Integer> set = (Set<Integer>) field.get(ccpp);
set.remove(factoryId);
} catch (Exception e) {
LOGGER.debug("Error while resetting ConfigurationClassPostProcessor caches", e);
}
| 281
| 99
| 380
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/ResetBeanPostProcessorCaches.java
|
ResetBeanPostProcessorCaches
|
reset
|
class ResetBeanPostProcessorCaches {
private static final AgentLogger LOGGER = AgentLogger.getLogger(ResetBeanPostProcessorCaches.class);
private static Class<?> getReflectionUtilsClassOrNull() {
try {
//This is probably a bad idea as Class.forName has lots of issues but this was easiest for now.
return Class.forName("org.springframework.util.ReflectionUtils");
} catch (ClassNotFoundException e) {
LOGGER.trace("Spring 4.1.x or below - ReflectionUtils class not found");
return null;
}
}
/**
* Reset all post processors associated with a bean factory.
*
* @param beanFactory beanFactory to use
*/
public static void reset(DefaultListableBeanFactory beanFactory) {<FILL_FUNCTION_BODY>}
public static void resetInitDestroyAnnotationBeanPostProcessorCache(InitDestroyAnnotationBeanPostProcessor bpp) {
try {
Field field = InitDestroyAnnotationBeanPostProcessor.class.getDeclaredField("lifecycleMetadataCache");
field.setAccessible(true);
Map lifecycleMetadataCache = (Map) field.get(bpp);
lifecycleMetadataCache.clear();
LOGGER.trace("Cache cleared: InitDestroyAnnotationBeanPostProcessor.lifecycleMetadataCache");
} catch (Exception e) {
throw new IllegalStateException("Unable to clear InitDestroyAnnotationBeanPostProcessor.lifecycleMetadataCache", e);
}
}
// @Autowired cache
public static void resetAutowiredAnnotationBeanPostProcessorCache(AutowiredAnnotationBeanPostProcessor bpp) {
try {
Field field = AutowiredAnnotationBeanPostProcessor.class.getDeclaredField("candidateConstructorsCache");
field.setAccessible(true);
// noinspection unchecked
Map<Class<?>, Constructor<?>[]> candidateConstructorsCache = (Map<Class<?>, Constructor<?>[]>) field.get(bpp);
candidateConstructorsCache.clear();
LOGGER.trace("Cache cleared: AutowiredAnnotationBeanPostProcessor.candidateConstructorsCache");
} catch (Exception e) {
throw new IllegalStateException("Unable to clear AutowiredAnnotationBeanPostProcessor.candidateConstructorsCache", e);
}
resetAnnotationBeanPostProcessorCache(bpp, AutowiredAnnotationBeanPostProcessor.class);
}
/**
* deal injectionMetadataCache field of
* @see org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
* @see org.springframework.context.annotation.CommonAnnotationBeanPostProcessor
*/
private static void resetAnnotationBeanPostProcessorCache(Object object, Class<?> clazz) {
try {
Field field = clazz.getDeclaredField("injectionMetadataCache");
field.setAccessible(true);
//noinspection unchecked
Map<Class<?>, InjectionMetadata> injectionMetadataCache = (Map<Class<?>, InjectionMetadata>) field.get(object);
injectionMetadataCache.clear();
// noinspection unchecked
LOGGER.trace("Cache cleared: AutowiredAnnotationBeanPostProcessor/CommonAnnotationBeanPostProcessor"
+ " injectionMetadataCache");
} catch (Exception e) {
throw new IllegalStateException("Unable to clear "
+ "AutowiredAnnotationBeanPostProcessor/CommonAnnotationBeanPostProcessor injectionMetadataCache", e);
}
}
}
|
Class<?> c = getReflectionUtilsClassOrNull();
if (c != null) {
try {
Method m = c.getDeclaredMethod("clearCache");
m.invoke(null);
LOGGER.trace("Cleared Spring 4.2+ internal method/field cache.");
} catch (Exception version42Failed) {
LOGGER.debug("Failed to clear internal method/field cache, it's normal with spring 4.1.x or lower", version42Failed);
// spring 4.0.x, 4.1.x without clearCache method, clear manually
Object declaredMethodsCache = ReflectionHelper.getNoException(null, c, "declaredMethodsCache");
if (declaredMethodsCache != null) {
((Map<?, ?>) declaredMethodsCache).clear();
}
Object declaredFieldsCache1 = ReflectionHelper.getNoException(null, c, "declaredFieldsCache");
if (declaredFieldsCache1 != null) {
((Map<?, ?>) declaredFieldsCache1).clear();
}
}
}
for (BeanPostProcessor bpp : beanFactory.getBeanPostProcessors()) {
if (bpp instanceof AutowiredAnnotationBeanPostProcessor) {
resetAutowiredAnnotationBeanPostProcessorCache((AutowiredAnnotationBeanPostProcessor) bpp);
} else if (bpp instanceof CommonAnnotationBeanPostProcessor) {
resetAnnotationBeanPostProcessorCache(bpp, CommonAnnotationBeanPostProcessor.class);
} else if (bpp instanceof InitDestroyAnnotationBeanPostProcessor) {
resetInitDestroyAnnotationBeanPostProcessorCache((InitDestroyAnnotationBeanPostProcessor) bpp);
}
}
| 858
| 413
| 1,271
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/ResetRequestMappingCaches.java
|
ResetRequestMappingCaches
|
reset
|
class ResetRequestMappingCaches {
private static AgentLogger LOGGER = AgentLogger.getLogger(ResetRequestMappingCaches.class);
private static Class<?> getHandlerMethodMappingClassOrNull() {
try {
//This is probably a bad idea as Class.forName has lots of issues but this was easiest for now.
return Class.forName("org.springframework.web.servlet.handler.AbstractHandlerMethodMapping");
} catch (ClassNotFoundException e) {
LOGGER.trace("HandlerMethodMapping class not found");
return null;
}
}
public static void reset(DefaultListableBeanFactory beanFactory) {<FILL_FUNCTION_BODY>}
}
|
Class<?> c = getHandlerMethodMappingClassOrNull();
if (c == null)
return;
Map<String, ?> mappings =
BeanFactoryUtils.beansOfTypeIncludingAncestors(beanFactory, c, true, false);
if (mappings.isEmpty()) {
LOGGER.trace("Spring: no HandlerMappings found");
}
try {
for (Entry<String, ?> e : mappings.entrySet()) {
Object am = e.getValue();
LOGGER.trace("Spring: clearing HandlerMapping for {}", am.getClass());
try {
Field f = c.getDeclaredField("handlerMethods");
f.setAccessible(true);
((Map<?,?>)f.get(am)).clear();
f = c.getDeclaredField("urlMap");
f.setAccessible(true);
((Map<?,?>)f.get(am)).clear();
try {
f = c.getDeclaredField("nameMap");
f.setAccessible(true);
((Map<?,?>)f.get(am)).clear();
} catch(NoSuchFieldException nsfe) {
LOGGER.trace("Probably using Spring 4.0 or below: {}", nsfe.getMessage());
}
} catch(NoSuchFieldException nsfe) {
LOGGER.trace("Probably using Spring 4.2+", nsfe.getMessage());
Method m = c.getDeclaredMethod("getHandlerMethods", new Class[0]);
Class<?>[] parameterTypes = new Class[1];
parameterTypes[0] = Object.class;
Method u = c.getDeclaredMethod("unregisterMapping", parameterTypes);
Map<?,?> unmodifiableHandlerMethods = (Map<?,?>) m.invoke(am);
Object[] keys = unmodifiableHandlerMethods.keySet().toArray();
unmodifiableHandlerMethods = null;
for (Object key : keys) {
LOGGER.trace("Unregistering handler method {}", key);
u.invoke(am, key);
}
}
if (am instanceof InitializingBean) {
((InitializingBean) am).afterPropertiesSet();
}
}
} catch (Exception e) {
LOGGER.error("Failed to clear HandlerMappings", e);
}
| 172
| 585
| 757
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/ResetSpringStaticCaches.java
|
ResetSpringStaticCaches
|
resetBeanNamesByType
|
class ResetSpringStaticCaches {
private static AgentLogger LOGGER = AgentLogger.getLogger(ResetSpringStaticCaches.class);
/**
* Spring bean by type cache.
*
* Cache names change between versions, call via reflection and ignore errors.
*/
public static void resetBeanNamesByType(DefaultListableBeanFactory defaultListableBeanFactory) {<FILL_FUNCTION_BODY>}
/**
* Reset all caches.
*/
public static void reset() {
resetTypeVariableCache();
resetAnnotationUtilsCache();
resetReflectionUtilsCache();
resetResolvableTypeCache();
resetPropertyCache();
CachedIntrospectionResults.clearClassLoader(ResetSpringStaticCaches.class.getClassLoader());
}
private static void resetResolvableTypeCache() {
ReflectionHelper.invokeNoException(null, "org.springframework.core.ResolvableType",
ResetSpringStaticCaches.class.getClassLoader(), "clearCache", new Class<?>[] {});
}
private static void resetTypeVariableCache() {
try {
Field field = GenericTypeResolver.class.getDeclaredField("typeVariableCache");
field.setAccessible(true);
// noinspection unchecked
Map<Class, Map> typeVariableCache = (Map<Class, Map>) field.get(null);
typeVariableCache.clear();
LOGGER.trace("Cache cleared: GenericTypeResolver.typeVariableCache");
} catch (Exception e) {
throw new IllegalStateException("Unable to clear GenericTypeResolver.typeVariableCache", e);
}
}
private static void resetReflectionUtilsCache() {
ReflectionHelper.invokeNoException(null, "org.springframework.util.ReflectionUtils",
ResetSpringStaticCaches.class.getClassLoader(), "clearCache", new Class<?>[] {});
Map declaredMethodsCache = (Map) ReflectionHelper.getNoException(null, ReflectionUtils.class,
"declaredMethodsCache");
if (declaredMethodsCache != null) {
declaredMethodsCache.clear();
LOGGER.trace("Cache cleared: ReflectionUtils.declaredMethodsCache");
} else {
LOGGER.trace("Cache NOT cleared: ReflectionUtils.declaredMethodsCache not exists");
}
}
private static void resetAnnotationUtilsCache() {
ReflectionHelper.invokeNoException(null, "org.springframework.core.annotation.AnnotationUtils",
ResetSpringStaticCaches.class.getClassLoader(), "clearCache", new Class<?>[] {});
Map annotatedInterfaceCache = (Map) ReflectionHelper.getNoException(null, AnnotationUtils.class,
"annotatedInterfaceCache");
if (annotatedInterfaceCache != null) {
annotatedInterfaceCache.clear();
LOGGER.trace("Cache cleared: AnnotationUtils.annotatedInterfaceCache");
} else {
LOGGER.trace("Cache NOT cleared: AnnotationUtils.annotatedInterfaceCache not exists in target Spring verion (pre 3.1.x)");
}
Map findAnnotationCache = (Map) ReflectionHelper.getNoException(null, AnnotationUtils.class, "findAnnotationCache");
if (findAnnotationCache != null) {
findAnnotationCache.clear();
LOGGER.trace("Cache cleared: AnnotationUtils.findAnnotationCache");
} else {
LOGGER.trace("Cache NOT cleared: AnnotationUtils.findAnnotationCache not exists in target Spring version (pre 4.1)");
}
}
private static void resetPropertyCache() {
try {
ClassLoader classLoader = ResetSpringStaticCaches.class.getClassLoader();
Map annotationCache = (Map) ReflectionHelper.get(null,
classLoader.loadClass("org.springframework.core.convert.Property"), "annotationCache");
annotationCache.clear();
LOGGER.trace("Cache cleared: Property.annotationCache");
} catch (Exception e) {
LOGGER.trace("Unable to clear Property.annotationCache (ok before Spring 3.2.x)", e);
}
}
}
|
try {
Field field = DefaultListableBeanFactory.class.getDeclaredField("singletonBeanNamesByType");
field.setAccessible(true);
// noinspection unchecked
Map singletonBeanNamesByType = (Map) field.get(defaultListableBeanFactory);
singletonBeanNamesByType.clear();
} catch (Exception e) {
LOGGER.trace("Unable to clear DefaultListableBeanFactory.singletonBeanNamesByType cache (is Ok for pre 3.1.2 Spring version)", e);
}
try {
Field field = DefaultListableBeanFactory.class.getDeclaredField("allBeanNamesByType");
field.setAccessible(true);
// noinspection unchecked
Map allBeanNamesByType = (Map) field.get(defaultListableBeanFactory);
allBeanNamesByType.clear();
} catch (Exception e) {
LOGGER.trace("Unable to clear allBeanNamesByType cache (is Ok for pre 3.2 Spring version)");
}
try {
Field field = DefaultListableBeanFactory.class.getDeclaredField("nonSingletonBeanNamesByType");
field.setAccessible(true);
// noinspection unchecked
Map nonSingletonBeanNamesByType = (Map) field.get(defaultListableBeanFactory);
nonSingletonBeanNamesByType.clear();
} catch (Exception e) {
LOGGER.debug("Unable to clear nonSingletonBeanNamesByType cache (is Ok for pre 3.2 Spring version)");
}
| 1,023
| 387
| 1,410
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/core/ResetTransactionAttributeCaches.java
|
ResetTransactionAttributeCaches
|
reset
|
class ResetTransactionAttributeCaches {
private static final AgentLogger LOGGER = AgentLogger.getLogger(ResetTransactionAttributeCaches.class);
private static Map<Object, TransactionAttribute> attributeCache;
private static boolean tried = false;
public static void reset(DefaultListableBeanFactory beanFactory) {<FILL_FUNCTION_BODY>}
}
|
if (!beanFactory.containsBean("transactionAttributeSource")) {
return;
}
try {
if (attributeCache == null && !tried) {
//only try once
tried = true;
final AbstractFallbackTransactionAttributeSource transactionAttributeSource = beanFactory.getBean("transactionAttributeSource", AbstractFallbackTransactionAttributeSource.class);
Field attributeCacheField = AbstractFallbackTransactionAttributeSource.class.getDeclaredField("attributeCache");
attributeCacheField.setAccessible(true);
attributeCache = (Map<Object, TransactionAttribute>) attributeCacheField.get(transactionAttributeSource);
}
if (attributeCache != null) {
attributeCache.clear();
}
} catch (Exception e) {
LOGGER.error("Failed to reset @Transactional cache", e);
}
| 89
| 204
| 293
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/getbean/DetachableBeanHolder.java
|
DetachableBeanHolder
|
getBean
|
class DetachableBeanHolder implements Serializable {
private static final long serialVersionUID = -7443802320153815102L;
private Object bean;
private Object beanFactory;
private Class<?>[] paramClasses;
private Object[] paramValues;
private static List<WeakReference<DetachableBeanHolder>> beanProxies =
Collections.synchronizedList(new ArrayList<WeakReference<DetachableBeanHolder>>());
private static AgentLogger LOGGER = AgentLogger.getLogger(DetachableBeanHolder.class);
/**
*
* @param bean
* Spring Bean this object holds
* @param beanFactry
* Spring factory that produced the bean with a ProxyReplacer.FACTORY_METHOD_NAME method
* @param paramClasses
* @param paramValues
*/
public DetachableBeanHolder(Object bean, Object beanFactry, Class<?>[] paramClasses, Object[] paramValues) {
if (bean == null) {
LOGGER.error("Bean is null. The param value: {}", Arrays.toString(paramValues));
}
this.bean = bean;
this.beanFactory = beanFactry;
this.paramClasses = paramClasses;
this.paramValues = paramValues;
beanProxies.add(new WeakReference<DetachableBeanHolder>(this));
}
/**
* Clears the bean references inside all of the proxies
*/
public static void detachBeans() {
int i = 0;
synchronized (beanProxies) {
while (i < beanProxies.size()) {
DetachableBeanHolder beanHolder = beanProxies.get(i).get();
if (beanHolder != null) {
beanHolder.detach();
i++;
} else {
beanProxies.remove(i);
}
}
}
if (i > 0) {
LOGGER.info("{} Spring proxies reset", i);
} else {
LOGGER.debug("No spring proxies reset");
}
}
/**
* Clear the bean for this proxy
*/
public void detach() {
bean = null;
}
/**
* Sets current target bean.
* @return current target bean.
*/
public void setTarget(Object bean) {
this.bean = bean;
}
/**
* Returns current target bean.
* @return current target bean.
*/
public Object getTarget() {
return bean;
}
/**
* Returns an existing bean instance or retrieves and stores new bean from the Spring BeanFactory
*
* @return Bean this instance holds
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public Object getBean() throws IllegalAccessException, InvocationTargetException {<FILL_FUNCTION_BODY>}
protected boolean isBeanLoaded(){
return bean != null;
}
}
|
Object beanCopy = bean;
if (beanCopy == null) {
Method[] methods = beanFactory.getClass().getMethods();
for (Method factoryMethod : methods) {
if (ProxyReplacer.FACTORY_METHOD_NAME.equals(factoryMethod.getName())
&& Arrays.equals(factoryMethod.getParameterTypes(), paramClasses)) {
Object freshBean = factoryMethod.invoke(beanFactory, paramValues);
// Factory returns HA proxy, but current method is invoked from HA proxy!
// It might be the same object (if factory returns same object - meaning
// that although clearAllProxies() was called, this bean did not change)
// Unwrap the target bean, it is always available
// see org.hotswap.agent.plugin.spring.getbean.EnhancerProxyCreater.create()
if (freshBean instanceof SpringHotswapAgentProxy) {
freshBean = ((SpringHotswapAgentProxy) freshBean).$$ha$getTarget();
}
bean = freshBean;
beanCopy = bean;
if (beanCopy == null) {
LOGGER.debug("Bean of '{}' not loaded, {} ", bean.getClass().getName(), paramValues);
break;
}
LOGGER.info("Bean '{}' loaded", bean.getClass().getName());
break;
}
}
}
return beanCopy;
| 767
| 349
| 1,116
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/getbean/HotswapSpringInvocationHandler.java
|
HotswapSpringInvocationHandler
|
doInvoke
|
class HotswapSpringInvocationHandler extends DetachableBeanHolder implements InvocationHandler {
private static final long serialVersionUID = 8037007940960065166L;
/**
* @param beanFactry Spring beanFactory
* @param bean Spring bean
* @param paramClasses Parameter Classes of the Spring beanFactory method which returned the bean. The method is named
* ProxyReplacer.FACTORY_METHOD_NAME
* @param paramValues Parameter values of the Spring beanFactory method which returned the bean. The method is named
* ProxyReplacer.FACTORY_METHOD_NAME
*/
public HotswapSpringInvocationHandler(Object bean, Object beanFactry, Class<?>[] paramClasses, Object[] paramValues) {
super(bean, beanFactry, paramClasses, paramValues);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getName().equals("getWrappedObject")
&& method.getDeclaringClass().getName().equals("org.springframework.core.InfrastructureProxy")) {
for (Class<?> beanInterface : getBean().getClass().getInterfaces()) {
if (beanInterface.getName().equals("org.springframework.core.InfrastructureProxy")) {
return doInvoke(method, args);
}
}
return getBean();
}
return doInvoke(method, args);
}
private Object doInvoke(Method method, Object[] args) throws Throwable {<FILL_FUNCTION_BODY>}
}
|
try {
return method.invoke(getBean(), args);
} catch (InvocationTargetException e) {
throw e.getCause();
}
| 408
| 43
| 451
|
<methods>public void <init>(java.lang.Object, java.lang.Object, Class<?>[], java.lang.Object[]) ,public void detach() ,public static void detachBeans() ,public java.lang.Object getBean() throws java.lang.IllegalAccessException, java.lang.reflect.InvocationTargetException,public java.lang.Object getTarget() ,public void setTarget(java.lang.Object) <variables>private static org.hotswap.agent.logging.AgentLogger LOGGER,private java.lang.Object bean,private java.lang.Object beanFactory,private static List<WeakReference<org.hotswap.agent.plugin.spring.getbean.DetachableBeanHolder>> beanProxies,private Class<?>[] paramClasses,private java.lang.Object[] paramValues,private static final long serialVersionUID
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/getbean/ProxyReplacer.java
|
ProxyReplacer
|
register
|
class ProxyReplacer {
private static AgentLogger LOGGER = AgentLogger.getLogger(ProxyReplacer.class);
private static Class<?> infrastructureProxyClass;
/**
* Name of the Spring beanFactory method, which returns a bean
*/
public static final String FACTORY_METHOD_NAME = "getBean";
/**
* Clears the bean references inside all the proxies
*/
public static void clearAllProxies() {
DetachableBeanHolder.detachBeans();
}
/**
* Creates a proxied Spring bean. Called from within WebApp code by modification of Spring classes
*
* @param beanFactry Spring beanFactory
* @param bean Spring bean
* @param paramClasses Parameter Classes of the Spring beanFactory method which returned the bean. The method is named
* ProxyReplacer.FACTORY_METHOD_NAME
* @param paramValues Parameter values of the Spring beanFactory method which returned the bean. The method is named
* ProxyReplacer.FACTORY_METHOD_NAME
* @return Proxied bean
*/
public static Object register(Object beanFactry, Object bean, Class<?>[] paramClasses, Object[] paramValues) {<FILL_FUNCTION_BODY>}
private static Class<?> getInfrastructureProxyClass() throws ClassNotFoundException {
if (infrastructureProxyClass == null) {
infrastructureProxyClass = ProxyReplacer.class.getClassLoader().loadClass("org.springframework.core.InfrastructureProxy");
}
return infrastructureProxyClass;
}
}
|
if (bean == null) {
return bean;
}
if (SpringPlugin.basePackagePrefixes != null) {
boolean hasMatch = false;
for (String basePackagePrefix : SpringPlugin.basePackagePrefixes) {
if (bean.getClass().getName().startsWith(basePackagePrefix)) {
hasMatch = true;
break;
}
}
// bean from other package
if (!hasMatch) {
LOGGER.info("{} not in basePackagePrefix", bean.getClass().getName());
return bean;
}
}
// create proxy for prototype-scope beans and apsect proxied beans
if (bean.getClass().getName().startsWith("com.sun.proxy.$Proxy")) {
InvocationHandler handler = new HotswapSpringInvocationHandler(bean, beanFactry, paramClasses, paramValues);
Class<?>[] interfaces = bean.getClass().getInterfaces();
try {
if (!Arrays.asList(interfaces).contains(getInfrastructureProxyClass())) {
interfaces = Arrays.copyOf(interfaces, interfaces.length + 1);
interfaces[interfaces.length - 1] = getInfrastructureProxyClass();
}
} catch (ClassNotFoundException e) {
LOGGER.error("error adding org.springframework.core.InfrastructureProxy to proxy class", e);
}
// fix: it should be the classloader of the bean,
// or org.springframework.beans.factory.support.AbstractBeanFactory.getBeanClassLoader,
// but not the classLoader of the beanFactry
return Proxy.newProxyInstance(bean.getClass().getClassLoader(), interfaces, handler);
} else if (EnhancerProxyCreater.isSupportedCglibProxy(bean)) {
// already a proxy, skip..
if (bean.getClass().getName().contains("$HOTSWAPAGENT_")) {
return bean;
}
return EnhancerProxyCreater.createProxy(beanFactry, bean, paramClasses, paramValues);
}
return bean;
| 401
| 520
| 921
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/listener/SpringEventSource.java
|
SpringEventSource
|
addListener
|
class SpringEventSource {
private final static AgentLogger LOGGER = AgentLogger.getLogger(SpringEventSource.class);
public static final SpringEventSource INSTANCE = new SpringEventSource();
private SpringEventSource() {
}
private final Set<SpringListener<SpringEvent<?>>> listeners = new HashSet<>();
public void addListener(SpringListener<SpringEvent<?>> listener) {<FILL_FUNCTION_BODY>}
public void fireEvent(SpringEvent<?> event) {
for (SpringListener<SpringEvent<?>> listener : listeners) {
if (listener.shouldSkip(event)) {
continue;
}
try {
listener.onEvent(event);
} catch (Throwable e) {
LOGGER.warning("SpringListener onEvent error", e);
}
}
}
}
|
if (listener == null) {
return;
}
synchronized (listeners) {
if (listeners.contains(listener)) {
LOGGER.debug("SpringListener already registered, {}", listener);
return;
}
listeners.add(listener);
}
| 222
| 78
| 300
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/reload/BeanFactoryAssistant.java
|
BeanFactoryAssistant
|
existReload
|
class BeanFactoryAssistant {
private ConfigurableListableBeanFactory beanFactory;
private AtomicInteger reloadTimes;
private long lastReloadTime;
private volatile boolean isReload = false;
// keep the bean name and xml file relation for the beans which are defined in xml file and the bean contains placeholder
Map<String, String> placeHolderXmlMapping = new ConcurrentHashMap<>();
private static Map<ConfigurableListableBeanFactory, BeanFactoryAssistant> beanFactoryAssistants = new ConcurrentHashMap<>(4);
public BeanFactoryAssistant(ConfigurableListableBeanFactory beanFactory) {
this.beanFactory = beanFactory;
this.reloadTimes = new AtomicInteger(0);
this.lastReloadTime = System.currentTimeMillis();
beanFactoryAssistants.put(beanFactory, this);
}
public static boolean existReload() {<FILL_FUNCTION_BODY>}
public static BeanFactoryAssistant getBeanFactoryAssistant(ConfigurableListableBeanFactory beanFactory) {
return beanFactoryAssistants.get(beanFactory);
}
public static BeanFactoryAssistant getBeanFactoryAssistant(DefaultListableBeanFactory beanFactory) {
return beanFactoryAssistants.get(beanFactory);
}
public static BeanFactoryAssistant getBeanFactoryAssistant(AbstractAutowireCapableBeanFactory beanFactory) {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
return getBeanFactoryAssistant((ConfigurableListableBeanFactory) beanFactory);
}
return null;
}
public void increaseReloadTimes() {
this.reloadTimes.incrementAndGet();
this.lastReloadTime = System.currentTimeMillis();
}
public ConfigurableListableBeanFactory getBeanFactory() {
return beanFactory;
}
public void reset() {
this.reloadTimes.set(0);
this.lastReloadTime = System.currentTimeMillis();
}
public int getReloadTimes() {
return reloadTimes.get();
}
public long getLastReloadTime() {
return lastReloadTime;
}
public boolean isReload() {
return isReload;
}
public void setReload(boolean isReload) {
this.isReload = isReload;
}
/**
* check the bean is destroyed or not
* @param beanName
* @return
*/
public boolean isDestroyedBean(String beanName) {
if (beanFactory instanceof BeanFactoryLifecycle) {
return ((BeanFactoryLifecycle) beanFactory).hotswapAgent$isDestroyedBean(beanName);
}
return false;
}
}
|
for (BeanFactoryAssistant assistant : beanFactoryAssistants.values()) {
if (assistant.isReload) {
return true;
}
}
return false;
| 695
| 50
| 745
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/reload/ClassChangedCommand.java
|
ClassChangedCommand
|
executeCommand
|
class ClassChangedCommand extends MergeableCommand {
private static AgentLogger LOGGER = AgentLogger.getLogger(ClassChangedCommand.class);
private static final Set<String> IGNORE_PACKAGES = new HashSet<>();
ClassLoader appClassLoader;
Class clazz;
Scheduler scheduler;
static {
IGNORE_PACKAGES.add("org.hotswap.agent.plugin.spring.reload");
IGNORE_PACKAGES.add("org.hotswap.agent.plugin.spring.scanner");
}
public ClassChangedCommand(ClassLoader appClassLoader, Class clazz, Scheduler scheduler) {
this.appClassLoader = appClassLoader;
this.clazz = clazz;
this.scheduler = scheduler;
}
@Override
public void executeCommand() {<FILL_FUNCTION_BODY>}
}
|
try {
Class<?> targetClass = Class.forName("org.hotswap.agent.plugin.spring.reload.SpringChangedAgent", true, appClassLoader);
Method targetMethod = targetClass.getDeclaredMethod("addChangedClass", Class.class);
targetMethod.invoke(null, clazz);
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Plugin error, method not found", e);
} catch (InvocationTargetException e) {
LOGGER.error("Error invoking method", e);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Plugin error, illegal access", e);
} catch (ClassNotFoundException e) {
throw new IllegalStateException("Plugin error, Spring class not found in application classloader", e);
}
| 236
| 201
| 437
|
<methods>public non-sealed void <init>() ,public List<org.hotswap.agent.command.Command> getMergedCommands() ,public org.hotswap.agent.command.Command merge(org.hotswap.agent.command.Command) ,public List<org.hotswap.agent.command.Command> popMergedCommands() <variables>List<org.hotswap.agent.command.Command> mergedCommands
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/reload/PropertiesChangedCommand.java
|
PropertiesChangedCommand
|
executeCommand
|
class PropertiesChangedCommand extends MergeableCommand {
private static AgentLogger LOGGER = AgentLogger.getLogger(PropertiesChangedCommand.class);
ClassLoader appClassLoader;
URL url;
Scheduler scheduler;
public PropertiesChangedCommand(ClassLoader appClassLoader, URL url, Scheduler scheduler) {
this.appClassLoader = appClassLoader;
this.url = url;
this.scheduler = scheduler;
}
@Override
public void executeCommand() {<FILL_FUNCTION_BODY>}
}
|
try {
Class<?> clazz = Class.forName("org.hotswap.agent.plugin.spring.reload.SpringChangedAgent", true, appClassLoader);
Method method = clazz.getDeclaredMethod(
"addChangedProperty", new Class[]{URL.class});
method.invoke(null, url);
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Plugin error, method not found", e);
} catch (InvocationTargetException e) {
LOGGER.error("Error invoking method", e);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Plugin error, illegal access", e);
} catch (ClassNotFoundException e) {
throw new IllegalStateException("Plugin error, Spring class not found in application classloader", e);
}
| 139
| 204
| 343
|
<methods>public non-sealed void <init>() ,public List<org.hotswap.agent.command.Command> getMergedCommands() ,public org.hotswap.agent.command.Command merge(org.hotswap.agent.command.Command) ,public List<org.hotswap.agent.command.Command> popMergedCommands() <variables>List<org.hotswap.agent.command.Command> mergedCommands
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/reload/SpringChangedReloadCommand.java
|
SpringChangedReloadCommand
|
executeCommand
|
class SpringChangedReloadCommand extends MergeableCommand {
private static AgentLogger LOGGER = AgentLogger.getLogger(XmlsChangedCommand.class);
// unit test only
private static AtomicLong waitingTaskCount = new AtomicLong(0);
ClassLoader appClassLoader;
long timestamps;
public SpringChangedReloadCommand(ClassLoader appClassLoader) {
this.appClassLoader = appClassLoader;
this.timestamps = System.currentTimeMillis();
LOGGER.trace("SpringChangedReloadCommand created with timestamp '{}'", timestamps);
waitingTaskCount.incrementAndGet();
}
@Override
public void executeCommand() {<FILL_FUNCTION_BODY>}
// this is used by tests
public static boolean isEmptyTask() {
return waitingTaskCount.get() == 0;
}
}
|
// async call to avoid reload too much times
try {
Class<?> clazz = Class.forName("org.hotswap.agent.plugin.spring.reload.SpringChangedAgent", true, appClassLoader);
Method method = clazz.getDeclaredMethod(
"reload", long.class);
method.invoke(null, timestamps);
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Plugin error, method not found", e);
} catch (InvocationTargetException e) {
LOGGER.error("Error invoking method", e);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Plugin error, illegal access", e);
} catch (ClassNotFoundException e) {
throw new IllegalStateException("Plugin error, Spring class not found in application classloader", e);
} finally {
waitingTaskCount.decrementAndGet();
}
| 219
| 231
| 450
|
<methods>public non-sealed void <init>() ,public List<org.hotswap.agent.command.Command> getMergedCommands() ,public org.hotswap.agent.command.Command merge(org.hotswap.agent.command.Command) ,public List<org.hotswap.agent.command.Command> popMergedCommands() <variables>List<org.hotswap.agent.command.Command> mergedCommands
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/reload/SpringReloadConfig.java
|
SpringReloadConfig
|
setDelayMillis
|
class SpringReloadConfig {
public static int reloadDelayMillis = 1600;
public static void setDelayMillis(int delayMillis) {<FILL_FUNCTION_BODY>}
}
|
if (delayMillis > 30000) {
reloadDelayMillis = 30000;
return;
}
SpringReloadConfig.reloadDelayMillis = delayMillis;
| 56
| 56
| 112
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/reload/XmlsChangedCommand.java
|
XmlsChangedCommand
|
executeCommand
|
class XmlsChangedCommand extends MergeableCommand {
private static AgentLogger LOGGER = AgentLogger.getLogger(XmlsChangedCommand.class);
ClassLoader appClassLoader;
URL url;
Scheduler scheduler;
public XmlsChangedCommand(ClassLoader appClassLoader, URL url, Scheduler scheduler) {
this.appClassLoader = appClassLoader;
this.url = url;
this.scheduler = scheduler;
}
@Override
public void executeCommand() {<FILL_FUNCTION_BODY>}
}
|
try {
Class<?> clazz = Class.forName("org.hotswap.agent.plugin.spring.reload.SpringChangedAgent", true, appClassLoader);
Method method = clazz.getDeclaredMethod(
"addChangedXml", new Class[]{URL.class});
method.invoke(null, url);
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Plugin error, method not found", e);
} catch (InvocationTargetException e) {
LOGGER.error("Error invoking method", e);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Plugin error, illegal access", e);
} catch (ClassNotFoundException e) {
throw new IllegalStateException("Plugin error, Spring class not found in application classloader", e);
}
| 144
| 204
| 348
|
<methods>public non-sealed void <init>() ,public List<org.hotswap.agent.command.Command> getMergedCommands() ,public org.hotswap.agent.command.Command merge(org.hotswap.agent.command.Command) ,public List<org.hotswap.agent.command.Command> popMergedCommands() <variables>List<org.hotswap.agent.command.Command> mergedCommands
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/reload/YamlChangedCommand.java
|
YamlChangedCommand
|
executeCommand
|
class YamlChangedCommand extends MergeableCommand {
private static AgentLogger LOGGER = AgentLogger.getLogger(YamlChangedCommand.class);
ClassLoader appClassLoader;
URL url;
Scheduler scheduler;
public YamlChangedCommand(ClassLoader appClassLoader, URL url, Scheduler scheduler) {
this.appClassLoader = appClassLoader;
this.url = url;
this.scheduler = scheduler;
}
@Override
public void executeCommand() {<FILL_FUNCTION_BODY>}
}
|
try {
Class<?> clazz = Class.forName("org.hotswap.agent.plugin.spring.reload.SpringChangedAgent", true, appClassLoader);
Method method = clazz.getDeclaredMethod(
"addChangedYaml", new Class[]{URL.class});
method.invoke(null, url);
} catch (Exception e) {
throw new RuntimeException("YamlChangedCommand.execute error", e);
}
| 142
| 115
| 257
|
<methods>public non-sealed void <init>() ,public List<org.hotswap.agent.command.Command> getMergedCommands() ,public org.hotswap.agent.command.Command merge(org.hotswap.agent.command.Command) ,public List<org.hotswap.agent.command.Command> popMergedCommands() <variables>List<org.hotswap.agent.command.Command> mergedCommands
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/scanner/ClassPathBeanRefreshCommand.java
|
ClassPathBeanRefreshCommand
|
isDeleteEvent
|
class ClassPathBeanRefreshCommand extends MergeableCommand {
private static AgentLogger LOGGER = AgentLogger.getLogger(ClassPathBeanRefreshCommand.class);
ClassLoader appClassLoader;
String basePackage;
String className;
// either event or classDefinition is set by constructor (watcher or transformer)
WatchFileEvent event;
byte[] classDefinition;
Scheduler scheduler;
public ClassPathBeanRefreshCommand(ClassLoader appClassLoader, String basePackage, String className,
byte[] classDefinition, Scheduler scheduler) {
this.appClassLoader = appClassLoader;
this.basePackage = basePackage;
this.className = className;
this.classDefinition = classDefinition;
this.scheduler = scheduler;
}
public ClassPathBeanRefreshCommand(ClassLoader appClassLoader, String basePackage, String className,
WatchFileEvent event, Scheduler scheduler) {
this.appClassLoader = appClassLoader;
this.basePackage = basePackage;
this.event = event;
this.className = className;
this.scheduler = scheduler;
}
@Override
public void executeCommand() {
if (isDeleteEvent()) {
LOGGER.trace("Skip Spring reload for delete event on class '{}'", className);
return;
}
try {
if (classDefinition == null) {
try {
this.classDefinition = IOUtils.toByteArray(event.getURI());
} catch (IllegalArgumentException e) {
LOGGER.debug("File {} not found on filesystem (deleted?). Unable to refresh associated Spring bean.", event.getURI());
return;
}
}
LOGGER.debug("Executing ClassPathBeanDefinitionScannerAgent.refreshClass('{}')", className);
Class<?> clazz = Class.forName("org.hotswap.agent.plugin.spring.scanner.ClassPathBeanDefinitionScannerAgent", true, appClassLoader);
Method method = clazz.getDeclaredMethod(
"refreshClassAndCheckReload", new Class[] {ClassLoader.class, String.class, String.class, byte[].class});
method.invoke(null, appClassLoader , basePackage, basePackage, classDefinition);
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Plugin error, method not found", e);
} catch (InvocationTargetException e) {
LOGGER.error("Error refreshing class {} in classLoader {}", e, className, appClassLoader);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Plugin error, illegal access", e);
} catch (ClassNotFoundException e) {
throw new IllegalStateException("Plugin error, Spring class not found in application classloader", e);
}
}
/**
* Check all merged events for delete and create events. If delete without create is found, than assume
* file was deleted.
*/
private boolean isDeleteEvent() {<FILL_FUNCTION_BODY>}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ClassPathBeanRefreshCommand that = (ClassPathBeanRefreshCommand) o;
if (!appClassLoader.equals(that.appClassLoader)) return false;
if (!className.equals(that.className)) return false;
return true;
}
@Override
public int hashCode() {
int result = appClassLoader.hashCode();
result = 31 * result + className.hashCode();
return result;
}
@Override
public String toString() {
return "ClassPathBeanRefreshCommand{" +
"appClassLoader=" + appClassLoader +
", basePackage='" + basePackage + '\'' +
", className='" + className + '\'' +
'}';
}
}
|
// for all merged commands including this command
List<ClassPathBeanRefreshCommand> mergedCommands = new ArrayList<>();
for (Command command : getMergedCommands()) {
mergedCommands.add((ClassPathBeanRefreshCommand) command);
}
mergedCommands.add(this);
boolean createFound = false;
boolean deleteFound = false;
for (ClassPathBeanRefreshCommand command : mergedCommands) {
if (command.event != null) {
if (command.event.getEventType().equals(FileEvent.DELETE))
deleteFound = true;
if (command.event.getEventType().equals(FileEvent.CREATE))
createFound = true;
}
}
LOGGER.trace("isDeleteEvent result {}: createFound={}, deleteFound={}", createFound, deleteFound);
return !createFound && deleteFound;
| 984
| 222
| 1,206
|
<methods>public non-sealed void <init>() ,public List<org.hotswap.agent.command.Command> getMergedCommands() ,public org.hotswap.agent.command.Command merge(org.hotswap.agent.command.Command) ,public List<org.hotswap.agent.command.Command> popMergedCommands() <variables>List<org.hotswap.agent.command.Command> mergedCommands
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/scanner/SpringBeanWatchEventListener.java
|
SpringBeanWatchEventListener
|
onEvent
|
class SpringBeanWatchEventListener implements WatchEventListener {
private static final AgentLogger LOGGER = AgentLogger.getLogger(SpringBeanWatchEventListener.class);
/**
* If a class is modified in IDE, sequence of multiple events is generated -
* class file DELETE, CREATE, MODIFY, than Hotswap transformer is invoked.
* ClassPathBeanRefreshCommand tries to merge these events into single command.
* Wait this this timeout after class file event.
*/
private static final int WAIT_ON_CREATE = 600;
private Scheduler scheduler;
private ClassLoader appClassLoader;
private String basePackage;
public SpringBeanWatchEventListener(Scheduler scheduler, ClassLoader appClassLoader, String basePackage) {
this.scheduler = scheduler;
this.appClassLoader = appClassLoader;
this.basePackage = basePackage;
}
@Override
public void onEvent(WatchFileEvent event) {<FILL_FUNCTION_BODY>}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
SpringBeanWatchEventListener that = (SpringBeanWatchEventListener) o;
return Objects.equals(appClassLoader, that.appClassLoader) && Objects.equals(basePackage, that.basePackage);
}
@Override
public int hashCode() {
return Objects.hash(appClassLoader, basePackage);
}
}
|
// new File
if (event.getEventType() == FileEvent.CREATE && event.isFile() && event.getURI().toString().endsWith(".class")) {
// check that the class is not loaded by the classloader yet (avoid duplicate reload)
String className;
try {
className = IOUtils.urlToClassName(event.getURI());
} catch (IOException e) {
LOGGER.trace("Watch event on resource '{}' skipped, probably Ok because of delete/create event " +
"sequence (compilation not finished yet).", e, event.getURI());
return;
}
if (!ClassLoaderHelper.isClassLoaded(appClassLoader, className)) {
// refresh spring only for new classes
scheduler.scheduleCommand(new ClassPathBeanRefreshCommand(appClassLoader,
basePackage, className, event, scheduler), WAIT_ON_CREATE);
LOGGER.trace("Scheduling Spring reload for class '{}' in classLoader {}", className, appClassLoader);
scheduler.scheduleCommand(new SpringChangedReloadCommand(appClassLoader), SpringReloadConfig.reloadDelayMillis);
}
}
| 380
| 287
| 667
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/BeanFactoryTransformer.java
|
BeanFactoryTransformer
|
registerAbstractAutowireCapableBeanFactory
|
class BeanFactoryTransformer {
private static final AgentLogger LOGGER = AgentLogger.getLogger(BeanFactoryTransformer.class);
@OnClassLoadEvent(classNameRegexp = "org.springframework.beans.factory.support.DefaultSingletonBeanRegistry")
public static void registerDefaultSingletonBeanRegistry(ClassLoader appClassLoader, CtClass clazz,
ClassPool classPool) throws NotFoundException, CannotCompileException {
clazz.addField(
CtField.make("private java.util.Set hotswapAgent$destroyBean = new java.util.HashSet();", clazz));
clazz.addInterface(classPool.get("org.hotswap.agent.plugin.spring.transformers.api.BeanFactoryLifecycle"));
clazz.addMethod(CtNewMethod.make(
"public boolean hotswapAgent$isDestroyedBean(String beanName) { return hotswapAgent$destroyBean.contains"
+ "(beanName); }",
clazz));
clazz.addMethod(CtNewMethod.make(
"public void hotswapAgent$destroyBean(String beanName) { hotswapAgent$destroyBean.add(beanName); }",
clazz));
clazz.addMethod(
CtNewMethod.make("public void hotswapAgent$clearDestroyBean() { hotswapAgent$destroyBean.clear(); }",
clazz));
CtMethod destroySingletonMethod = clazz.getDeclaredMethod("destroySingleton",
new CtClass[] {classPool.get(String.class.getName())});
destroySingletonMethod.insertAfter(
BeanFactoryProcessor.class.getName() + ".postProcessDestroySingleton($0, $1);");
}
@OnClassLoadEvent(classNameRegexp = "org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory")
public static void registerAbstractAutowireCapableBeanFactory(ClassLoader appClassLoader, CtClass clazz,
ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
clazz.addField(CtField.make("private static final org.hotswap.agent.logging.AgentLogger $$ha$LOGGER = " +
"org.hotswap.agent.logging.AgentLogger.getLogger(org.springframework.beans.factory.annotation"
+ ".InitDestroyAnnotationBeanPostProcessor.class);",
clazz));
CtMethod createBeanMethod = clazz.getDeclaredMethod("createBean", new CtClass[] {
classPool.get(String.class.getName()),
classPool.get("org.springframework.beans.factory.support.RootBeanDefinition"),
classPool.get(Object[].class.getName())});
createBeanMethod.insertAfter(BeanFactoryProcessor.class.getName() + ".postProcessCreateBean($0, $1, $2);");
// try catch for custom init method
CtMethod[] invokeCustomInitMethods = clazz.getDeclaredMethods("invokeCustomInitMethod");
if (invokeCustomInitMethods.length != 1) {
LOGGER.error("Unexpected number of 'invokeCustomInitMethod' methods found. Expected: 1, Found: " + invokeCustomInitMethods.length);
}
invokeCustomInitMethods[0].addCatch(
InitMethodEnhance.catchException("$2", "$$ha$LOGGER", "$e", "invokeCustomInitMethod", false),
classPool.get("java.lang.Throwable"));
// try catch for afterPropertiesSet
CtMethod invokeInitMethod = clazz.getDeclaredMethod("invokeInitMethods",
new CtClass[] {classPool.get(String.class.getName()), classPool.get("java.lang.Object"),
classPool.get("org.springframework.beans.factory.support.RootBeanDefinition")});
invokeInitMethod.addCatch(
InitMethodEnhance.catchException("$2", "$$ha$LOGGER", "$e", "invokeInitMethods", false),
classPool.get("java.lang.Throwable"));
| 529
| 492
| 1,021
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/ClassPathBeanDefinitionScannerTransformer.java
|
ClassPathBeanDefinitionScannerTransformer
|
transform
|
class ClassPathBeanDefinitionScannerTransformer {
private static final AgentLogger LOGGER = AgentLogger.getLogger(ClassPathBeanDefinitionScannerTransformer.class);
/**
* Insert at the beginning of the method:
* <pre>public Set<BeanDefinition> findCandidateComponents(String basePackage)</pre>
* new code to initialize ClassPathBeanDefinitionScannerAgent for a base class
* It would be better to override a more appropriate method
* org.springframework.context.annotation.ClassPathBeanDefinitionScanner.scan() directly,
* however there are issues with javassist and varargs parameters.
*/
@OnClassLoadEvent(classNameRegexp = "org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider")
public static void transform(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
if (SpringPlugin.basePackagePrefixes == null) {
CtMethod method = clazz.getDeclaredMethod("findCandidateComponents", new CtClass[]{classPool.get("java.lang.String")});
method.insertAfter(
"if (this instanceof org.springframework.context.annotation.ClassPathBeanDefinitionScanner) {" +
" if (org.hotswap.agent.plugin.spring.scanner.ClassPathBeanDefinitionScannerAgent.getInstance($1) == null) {" +
" org.hotswap.agent.plugin.spring.scanner.ClassPathBeanDefinitionScannerAgent.getInstance(" +
"(org.springframework.context.annotation.ClassPathBeanDefinitionScanner)this).registerBasePackage($1);" +
" }" +
"}");
LOGGER.debug("Class 'org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider' " +
"patched with basePackage registration.");
} else {
LOGGER.debug("No need to register scanned path, instead just register 'spring.basePackagePrefix' in " +
"configuration file.");
}
| 225
| 283
| 508
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/ConfigurationClassPostProcessorTransformer.java
|
ConfigurationClassPostProcessorTransformer
|
transform
|
class ConfigurationClassPostProcessorTransformer {
private static final AgentLogger LOGGER = AgentLogger.getLogger(ConfigurationClassPostProcessorTransformer.class);
@OnClassLoadEvent(classNameRegexp = "org.springframework.context.annotation.ConfigurationClassPostProcessor")
public static void transform(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
LOGGER.debug("Class 'org.springframework.context.annotation.ConfigurationClassPostProcessor' patched with processor registration.");
CtMethod method = clazz.getDeclaredMethod("processConfigBeanDefinitions",
new CtClass[]{classPool.get("org.springframework.beans.factory.support.BeanDefinitionRegistry")});
method.insertAfter("org.hotswap.agent.plugin.spring.core.ConfigurationClassPostProcessorEnhance.getInstance($1)." +
"setProcessor(this);");
try {
/**
* remove warning log in org.springframework.context.annotation.ConfigurationClassPostProcessor.enhanceConfigurationClasses
*/
CtMethod enhanceConfigurationClassesMethod = clazz.getDeclaredMethod("enhanceConfigurationClasses");
enhanceConfigurationClassesMethod.instrument(new ExprEditor() {
@Override
public void edit(MethodCall m) throws CannotCompileException {
if (m.getClassName().equals("org.springframework.beans.factory.config.ConfigurableListableBeanFactory")
&& m.getMethodName().equals("containsSingleton")) {
m.replace("{$_ = $proceed($$) && " +
"(org.hotswap.agent.plugin.spring.reload.BeanFactoryAssistant.getBeanFactoryAssistant($0) == null || " +
"!org.hotswap.agent.plugin.spring.reload.BeanFactoryAssistant.getBeanFactoryAssistant($0).isReload());}");
}
}
});
} catch (NotFoundException e) {
// ignore
}
| 104
| 391
| 495
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/InitDestroyAnnotationBeanPostProcessorTransformer.java
|
InitDestroyAnnotationBeanPostProcessorTransformer
|
transform
|
class InitDestroyAnnotationBeanPostProcessorTransformer {
private static final AgentLogger LOGGER = AgentLogger.getLogger(
InitDestroyAnnotationBeanPostProcessorTransformer.class);
@OnClassLoadEvent(classNameRegexp = "org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor")
public static void transform(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
LOGGER.debug(
"Class 'org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor' patched with"
+ " catch exception.");
clazz.addField(CtField.make("private static final org.hotswap.agent.logging.AgentLogger $$ha$LOGGER = " +
"org.hotswap.agent.logging.AgentLogger.getLogger(org.springframework.beans.factory.annotation"
+ ".InitDestroyAnnotationBeanPostProcessor.class);",
clazz));
CtMethod method = clazz.getDeclaredMethod("postProcessBeforeInitialization",
new CtClass[] {classPool.get("java.lang.Object"), classPool.get("java.lang.String")});
String code = "{"
+ "if (!org.hotswap.agent.plugin.spring.reload.BeanFactoryAssistant.existReload()) {"
+ " throw $e ; }"
+ "else {"
+ "if ($$ha$LOGGER.isDebugEnabled()) {"
+ "$$ha$LOGGER.debug(\"Failed to invoke init method of {} from @PostConstructor: {}\", $e, "
+ "new java.lang.Object[]{$1.getClass().getName(),$e.getMessage()});"
+ "} else {"
+ "$$ha$LOGGER.warning(\"Failed to invoke init method of {} from @PostConstructor: {}\", "
+ "new java.lang.Object[]{$1.getClass().getName(),$e.getMessage()});"
+ "}"
+ "return $1;"
+ "}"
+ "}";
method.addCatch(code, classPool.get("org.springframework.beans.factory.BeanCreationException"));
| 118
| 429
| 547
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/PlaceholderConfigurerSupportTransformer.java
|
PlaceholderConfigurerSupportTransformer
|
transform
|
class PlaceholderConfigurerSupportTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(PlaceholderConfigurerSupportTransformer.class);
/**
* @param clazz
* @param classPool
* @throws NotFoundException
* @throws CannotCompileException
*/
@OnClassLoadEvent(classNameRegexp = "org.springframework.beans.factory.config.PlaceholderConfigurerSupport")
public static void transform(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
for (CtClass interfaceClazz : clazz.getInterfaces()) {
if (interfaceClazz.getName().equals("org.hotswap.agent.plugin.spring.transformers.api.ValueResolverSupport")) {
return;
}
}
clazz.addInterface(classPool.get("org.hotswap.agent.plugin.spring.transformers.api.ValueResolverSupport"));
clazz.addField(CtField.make("private java.util.List _resolvers;", clazz), "new java.util.ArrayList(2)");
clazz.addMethod(CtMethod.make("public java.util.List valueResolvers() { return this._resolvers; }", clazz));
CtMethod ctMethod = clazz.getDeclaredMethod("doProcessProperties", new CtClass[]{classPool.get("org.springframework.beans.factory.config.ConfigurableListableBeanFactory"),
classPool.get("org.springframework.util.StringValueResolver")});
ctMethod.insertBefore("org.hotswap.agent.plugin.spring.reload.SpringChangedAgent.collectPlaceholderProperties($1); " +
"this._resolvers.add($2);");
LOGGER.debug("class 'org.springframework.beans.factory.config.PlaceholderConfigurerSupport' patched with placeholder keep.");
| 148
| 330
| 478
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/PostProcessorRegistrationDelegateTransformer.java
|
PostProcessorRegistrationDelegateTransformer
|
edit
|
class PostProcessorRegistrationDelegateTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(PostProcessorRegistrationDelegateTransformer.class);
/**
* @param clazz
* @param classPool
* @throws NotFoundException
* @throws CannotCompileException
*/
@OnClassLoadEvent(classNameRegexp = "org.springframework.context.support.PostProcessorRegistrationDelegate")
public static void transform(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {
clazz.addField(CtField.make("private static final org.hotswap.agent.logging.AgentLogger LOGGER = " +
"org.hotswap.agent.logging.AgentLogger.getLogger(org.springframework.context.support.PostProcessorRegistrationDelegate.class);", clazz));
CtMethod ctMethod = clazz.getDeclaredMethod("invokeBeanFactoryPostProcessors", new CtClass[]{classPool.get("java.util.Collection"),
classPool.get("org.springframework.beans.factory.config.ConfigurableListableBeanFactory")});
ctMethod.instrument(new ExprEditor() {
@Override
public void edit(MethodCall m) throws CannotCompileException {<FILL_FUNCTION_BODY>}
});
LOGGER.debug("class 'org.springframework.beans.factory.config.PlaceholderConfigurerSupport' patched with placeholder keep.");
}
}
|
if (m.getClassName().equals("org.springframework.beans.factory.config.BeanFactoryPostProcessor")
&& m.getMethodName().equals("postProcessBeanFactory")) {
m.replace("{ try{ $_ = $proceed($$); " +
"}catch (java.lang.Exception e) {\n" +
" LOGGER.debug(\"Failed to invoke BeanDefinitionRegistryPostProcessor: {}, reason:{}\",\n" +
" new java.lang.Object[]{$0.getClass().getName(), e.getMessage()});\n" +
" };}");
}
| 358
| 152
| 510
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/ProxyReplacerTransformer.java
|
ProxyReplacerTransformer
|
replaceBeanWithProxy
|
class ProxyReplacerTransformer {
public static final String FACTORY_METHOD_NAME = "getBean";
private static CtMethod overrideMethod(CtClass ctClass, CtMethod getConnectionMethodOfSuperclass)
throws NotFoundException, CannotCompileException {
final CtMethod m = CtNewMethod.delegator(getConnectionMethodOfSuperclass, ctClass);
ctClass.addMethod(m);
return m;
}
/**
*
* @param ctClass
* @throws NotFoundException
* @throws CannotCompileException
*/
@OnClassLoadEvent(classNameRegexp = "org.springframework.beans.factory.support.DefaultListableBeanFactory")
public static void replaceBeanWithProxy(CtClass ctClass) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
/**
* Disable cache usage in FastClass.Generator to avoid 'IllegalArgumentException: Protected method' exceptions
*
* @param ctClass
* @throws NotFoundException
* @throws CannotCompileException
*/
@OnClassLoadEvent(classNameRegexp = "org.springframework.cglib.reflect.FastClass.Generator")
public static void replaceSpringFastClassGenerator(CtClass ctClass) throws NotFoundException,
CannotCompileException {
CtConstructor[] constructors = ctClass.getConstructors();
for (CtConstructor ctConstructor : constructors) {
ctConstructor.insertAfter("setUseCache(false);");
}
}
/**
* Disable cache usage in FastClass.Generator to avoid 'IllegalArgumentException: Protected method' exceptions
*
* @param ctClass
* @throws NotFoundException
* @throws CannotCompileException
*/
@OnClassLoadEvent(classNameRegexp = "net.sf.cglib.reflect.FastClass.Generator")
public static void replaceCglibFastClassGenerator(CtClass ctClass) throws NotFoundException, CannotCompileException {
CtConstructor[] constructors = ctClass.getConstructors();
for (CtConstructor ctConstructor : constructors) {
ctConstructor.insertAfter("setUseCache(false);");
}
}
}
|
CtMethod[] methods = ctClass.getMethods();
for (CtMethod ctMethod : methods) {
if (!ctMethod.getName().equals(FACTORY_METHOD_NAME))
continue;
if (!ctClass.equals(ctMethod.getDeclaringClass())) {
ctMethod = overrideMethod(ctClass, ctMethod);
}
StringBuilder methodParamTypes = new StringBuilder();
for (CtClass type : ctMethod.getParameterTypes()) {
methodParamTypes.append(type.getName()).append(".class").append(", ");
}
ctMethod.insertAfter("if(true){return org.hotswap.agent.plugin.spring.getbean.ProxyReplacer.register($0, $_,new Class[]{"
+ methodParamTypes.substring(0, methodParamTypes.length() - 2) + "}, $args);}");
}
| 568
| 226
| 794
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/ResourcePropertySourceTransformer.java
|
ResourcePropertySourceTransformer
|
transform
|
class ResourcePropertySourceTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(ResourcePropertySourceTransformer.class);
/**
* Insert at the beginning of the method:
* <pre>public Set<BeanDefinition> findCandidateComponents(String basePackage)</pre>
* new code to initialize ClassPathBeanDefinøitionScannerAgent for a base class
* It would be better to override a more appropriate method
* org.springframework.context.annotation.ClassPathBeanDefinitionScanner.scan() directly,
* however there are issues with javassist and varargs parameters.
*/
@OnClassLoadEvent(classNameRegexp = "org.springframework.core.io.support.ResourcePropertySource")
public static void transform(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
clazz.addInterface(classPool.get("org.hotswap.agent.plugin.spring.transformers.api.ReloadableResourcePropertySource"));
clazz.addField(CtField.make("private org.springframework.core.io.support.EncodedResource encodedResource;", clazz));
clazz.addField(CtField.make("private org.springframework.core.io.Resource resource;", clazz));
CtConstructor ctConstructor0 = clazz.getDeclaredConstructor(new CtClass[]{classPool.get("java.lang.String"),
classPool.get("org.springframework.core.io.support.EncodedResource")});
ctConstructor0.insertBefore("this.encodedResource = $2;");
CtConstructor ctConstructor1 = clazz.getDeclaredConstructor(new CtClass[]{classPool.get("org.springframework.core.io.support.EncodedResource")});
ctConstructor1.insertBefore("this.encodedResource = $1;");
CtConstructor ctConstructor2 = clazz.getDeclaredConstructor(new CtClass[]{classPool.get("java.lang.String"),
classPool.get("org.springframework.core.io.Resource")});
ctConstructor2.insertBefore("this.resource = $2;");
CtConstructor ctConstructor3 = clazz.getDeclaredConstructor(new CtClass[]{classPool.get("org.springframework.core.io.Resource")});
ctConstructor3.insertBefore("this.resource = $1;");
clazz.addMethod(CtMethod.make("public org.springframework.core.io.support.EncodedResource encodedResource() { return this.encodedResource; }", clazz));
clazz.addMethod(CtMethod.make("public org.springframework.core.io.Resource resource() { return this.resource; }", clazz));
LOGGER.debug("class 'org.springframework.core.io.support.DefaultPropertySourceFactory' patched with PropertySource keep.");
| 219
| 484
| 703
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/XmlBeanDefinitionScannerTransformer.java
|
XmlBeanDefinitionScannerTransformer
|
transform
|
class XmlBeanDefinitionScannerTransformer {
private static AgentLogger LOGGER = AgentLogger.getLogger(XmlBeanDefinitionScannerTransformer.class);
/**
* Insert at the beginning of the method:
* <pre>public Set<BeanDefinition> findCandidateComponents(String basePackage)</pre>
* new code to initialize ClassPathBeanDefinitionScannerAgent for a base class
* It would be better to override a more appropriate method
* org.springframework.context.annotation.ClassPathBeanDefinitionScanner.scan() directly,
* however there are issues with javassist and varargs parameters.
*/
@OnClassLoadEvent(classNameRegexp = "org.springframework.beans.factory.xml.XmlBeanDefinitionReader")
public static void transform(CtClass clazz, ClassPool classPool) throws NotFoundException, CannotCompileException {<FILL_FUNCTION_BODY>}
}
|
CtMethod method = clazz.getDeclaredMethod("registerBeanDefinitions", new CtClass[]{
classPool.get("org.w3c.dom.Document"),
classPool.get("org.springframework.core.io.Resource")});
method.insertBefore(XmlBeanDefinitionScannerAgent.class.getName() + ".registerXmlBeanDefinitionScannerAgent(this, $2);");
LOGGER.debug("Class 'org.springframework.beans.factory.xml.XmlBeanDefinitionReader' patched with xmlReader registration.");
| 221
| 131
| 352
|
<no_super_class>
|
HotswapProjects_HotswapAgent
|
HotswapAgent/plugin/hotswap-agent-spring-plugin/src/main/java/org/hotswap/agent/plugin/spring/transformers/support/InitMethodEnhance.java
|
InitMethodEnhance
|
catchException
|
class InitMethodEnhance {
public static String catchException(String objectName, String loggerName, String exceptionName, String from,
boolean hasReturnValue) {<FILL_FUNCTION_BODY>}
}
|
return "{"
+ "if (org.hotswap.agent.plugin.spring.reload.BeanFactoryAssistant.getBeanFactoryAssistant($0) == null || "
+ " !org.hotswap.agent.plugin.spring.reload.BeanFactoryAssistant.getBeanFactoryAssistant($0).isReload()) {"
+ " throw " + exceptionName + " ; }"
+ "else {"
+ " " + loggerName + ".warning(\"Failed to invoke init method of {} from {}: {}\", "
+ "new java.lang.Object[]{" + objectName + ".getClass().getName(),\""
+ from + "\", "+ exceptionName + ".getMessage()});"
+ " " + loggerName + ".debug(\"the detail reason as following{}: \", " + exceptionName
+ ", new java.lang.Object[]{ \" \"});" + (hasReturnValue ? " return " + objectName + ";" : "return;")
+ " } "
+ "}";
| 54
| 252
| 306
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.