Exemple #1
0
    private String fixTypes2(
        ArrayList<TypeVar> scc, HashSet<String> lowersSet, org.hotswap.agent.javassist.ClassPool cp)
        throws org.hotswap.agent.javassist.NotFoundException {
      Iterator<String> it = lowersSet.iterator();
      if (lowersSet.size() == 0) {
        return null; // only NullType
      } else if (lowersSet.size() == 1) {
        return it.next();
      } else {
        org.hotswap.agent.javassist.CtClass cc = cp.get(it.next());
        while (it.hasNext()) {
          cc = commonSuperClassEx(cc, cp.get(it.next()));
        }

        if (cc.getSuperclass() == null || isObjectArray(cc)) {
          cc = fixByUppers(scc, cp, new HashSet<TypeVar>(), cc);
        }

        if (cc.isArray()) {
          return org.hotswap.agent.javassist.bytecode.Descriptor.toJvmName(cc);
        } else {
          return cc.getName();
        }
      }
    }
Exemple #2
0
 /** Finds the most specific common super class of the given classes by considering array types. */
 public static org.hotswap.agent.javassist.CtClass commonSuperClassEx(
     org.hotswap.agent.javassist.CtClass one, org.hotswap.agent.javassist.CtClass two)
     throws org.hotswap.agent.javassist.NotFoundException {
   if (one == two) {
     return one;
   } else if (one.isArray() && two.isArray()) {
     org.hotswap.agent.javassist.CtClass ele1 = one.getComponentType();
     org.hotswap.agent.javassist.CtClass ele2 = two.getComponentType();
     org.hotswap.agent.javassist.CtClass element = commonSuperClassEx(ele1, ele2);
     if (element == ele1) {
       return one;
     } else if (element == ele2) {
       return two;
     } else {
       return one.getClassPool()
           .get(element == null ? "java.lang.Object" : element.getName() + "[]");
     }
   } else if (one.isPrimitive() || two.isPrimitive()) {
     return null; // TOP
   } else if (one.isArray() || two.isArray()) {
     // two.isArray())
     return one.getClassPool().get("java.lang.Object");
   } else {
     return commonSuperClass(one, two);
   }
 }
 @OnClassLoadEvent(classNameRegexp = ".*", events = LoadEvent.REDEFINE)
 public void entityReload(ClassLoader classLoader, CtClass clazz, Class original) {
   if (AnnotationHelper.hasAnnotation(original, PATH_ANNOTATION)
       || AnnotationHelper.hasAnnotation(clazz, PATH_ANNOTATION)) {
     LOGGER.debug(
         "Reload @Path annotated class {}, original classloader {}",
         clazz.getName(),
         original.getClassLoader());
     refresh(classLoader, 500);
   }
 }
  /** Run plugin the method. */
  public void onWatchEvent(
      PluginAnnotation<T> pluginAnnotation, WatchFileEvent event, ClassLoader classLoader) {
    final T annot = pluginAnnotation.getAnnotation();
    Object plugin = pluginAnnotation.getPlugin();

    // regular files filter
    if (watchEventDTO.isOnlyRegularFiles() && !event.isFile()) {
      LOGGER.trace("Skipping URI {} because it is not a regular file.", event.getURI());
      return;
    }

    // watch type filter
    if (!Arrays.asList(watchEventDTO.getEvents()).contains(event.getEventType())) {
      LOGGER.trace("Skipping URI {} because it is not a requested event.", event.getURI());
      return;
    }

    // resource name filter regexp
    if (watchEventDTO.getFilter() != null && watchEventDTO.getFilter().length() > 0) {
      if (!event.getURI().toString().matches(watchEventDTO.getFilter())) {
        LOGGER.trace(
            "Skipping URI {} because it does not match filter.",
            event.getURI(),
            watchEventDTO.getFilter());
        return;
      }
    }

    // we may need to crate CtClass on behalf of the client and close it after invocation.
    CtClass ctClass = null;

    // class file regexp
    if (watchEventDTO.isClassFileEvent()) {
      try {
        // TODO creating class only to check name may slow down if lot of handlers is in use.
        ctClass = createCtClass(event.getURI(), classLoader);
      } catch (Exception e) {
        LOGGER.error("Unable create CtClass for URI '{}'.", e, event.getURI());
        return;
      }

      // unable to create CtClass or it's name does not match
      if (ctClass == null || !ctClass.getName().matches(watchEventDTO.getClassNameRegexp())) return;
    }

    LOGGER.debug(
        "Executing resource changed method {} on class {} for event {}",
        pluginAnnotation.getMethod().getName(),
        plugin.getClass().getName(),
        event);

    List<Object> args = new ArrayList<Object>();
    for (Class<?> type : pluginAnnotation.getMethod().getParameterTypes()) {
      if (type.isAssignableFrom(ClassLoader.class)) {
        args.add(classLoader);
      } else if (type.isAssignableFrom(URI.class)) {
        args.add(event.getURI());
      } else if (type.isAssignableFrom(URL.class)) {
        try {
          args.add(event.getURI().toURL());
        } catch (MalformedURLException e) {
          LOGGER.error("Unable to convert URI '{}' to URL.", e, event.getURI());
          return;
        }
      } else if (type.isAssignableFrom(ClassPool.class)) {
        args.add(ClassPool.getDefault());
      } else if (type.isAssignableFrom(FileEvent.class)) {
        args.add(event.getEventType());
      } else if (watchEventDTO.isClassFileEvent() && type.isAssignableFrom(CtClass.class)) {
        args.add(ctClass);
      } else if (watchEventDTO.isClassFileEvent() && type.isAssignableFrom(String.class)) {
        args.add(ctClass.getName());
      } else {
        LOGGER.error(
            "Unable to call method {} on plugin {}. Method parameter type {} is not recognized.",
            pluginAnnotation.getMethod().getName(),
            plugin.getClass().getName(),
            type);
        return;
      }
    }
    try {
      pluginAnnotation.getMethod().invoke(plugin, args.toArray());

      // close CtClass if created from here
      if (ctClass != null) {
        ctClass.detach();
      }
    } catch (IllegalAccessException e) {
      LOGGER.error(
          "IllegalAccessException in method {} on plugin {}",
          e,
          pluginAnnotation.getMethod().getName(),
          plugin.getClass().getName());
    } catch (InvocationTargetException e) {
      LOGGER.error(
          "InvocationTargetException in method {} on plugin {}",
          e,
          pluginAnnotation.getMethod().getName(),
          plugin.getClass().getName());
    }
  }
Exemple #5
0
 static boolean eq(
     org.hotswap.agent.javassist.CtClass one, org.hotswap.agent.javassist.CtClass two) {
   return one == two || one != null && two != null && one.getName().equals(two.getName());
 }