/**
   * Creats javaassist CtClass for bytecode manipulation. Add default classloader.
   *
   * @param uri uri
   * @param classLoader loader
   * @return created class
   * @throws org.hotswap.agent.javassist.NotFoundException
   */
  private CtClass createCtClass(URI uri, ClassLoader classLoader)
      throws NotFoundException, IOException {
    ClassPool cp = new ClassPool();
    cp.appendClassPath(new LoaderClassPath(classLoader));

    return cp.makeClass(new ByteArrayInputStream(IOUtils.toByteArray(uri)));
  }
Exemple #2
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();
        }
      }
    }
  @OnClassLoadEvent(classNameRegexp = "org.jboss.resteasy.plugins.server.servlet.FilterDispatcher")
  public static void patchFilterDispatcher(CtClass ctClass, ClassPool classPool)
      throws NotFoundException, CannotCompileException {

    CtClass fltCfgClass = classPool.get("javax.servlet.FilterConfig");
    CtField configField = new CtField(fltCfgClass, FIELD_NAME, ctClass);
    ctClass.addField(configField);

    CtClass setClass = classPool.get(java.util.Set.class.getName());
    CtField paramsField = new CtField(setClass, PARAMETER_FIELD_NAME, ctClass);
    ctClass.addField(paramsField);

    CtMethod methInit = ctClass.getDeclaredMethod("init");
    methInit.insertBefore(
        "{"
            + "   if(this."
            + PARAMETER_FIELD_NAME
            + " == null) {"
            + PluginManagerInvoker.buildInitializePlugin(ResteasyPlugin.class)
            + PluginManagerInvoker.buildCallPluginMethod(
                ResteasyPlugin.class, "registerDispatcher", "this", "java.lang.Object")
            + "   }"
            + "   this."
            + FIELD_NAME
            + " = $1;"
            + "   this."
            + PARAMETER_FIELD_NAME
            + " = "
            + ResteasyContextParams.class.getName()
            + ".init($1.getServletContext(), this."
            + PARAMETER_FIELD_NAME
            + "); "
            + "}");
  }
Exemple #4
0
    private org.hotswap.agent.javassist.CtClass fixByUppers(
        ArrayList<TypeVar> users,
        org.hotswap.agent.javassist.ClassPool cp,
        HashSet<TypeVar> visited,
        org.hotswap.agent.javassist.CtClass type)
        throws org.hotswap.agent.javassist.NotFoundException {
      if (users == null) {
        return type;
      }

      int size = users.size();
      for (int i = 0; i < size; i++) {
        TypeVar t = users.get(i);
        if (!visited.add(t)) {
          return type;
        }

        if (t.uppers != null) {
          int s = t.uppers.size();
          for (int k = 0; k < s; k++) {
            org.hotswap.agent.javassist.CtClass cc = cp.get(t.uppers.get(k));
            if (cc.subtypeOf(type)) {
              type = cc;
            }
          }
        }

        type = fixByUppers(t.usedBy, cp, visited, type);
      }

      return type;
    }
  /** 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());
    }
  }