private CtClass obtainCtClassInfo(AOPClassPool pool, String className, byte[] classfileBuffer)
     throws NotFoundException {
   try {
     return pool.getLocally(className);
   } catch (NotFoundException e) {
     // todo Bill Burke: this scares the shit out of me, but it must be done
     // I think it will screw up hotdeployment at some time.  Then again, maybe not ;)
     ByteArrayClassPath cp = new ByteArrayClassPath(className, classfileBuffer);
     pool.insertClassPath(cp);
     return pool.getLocally(className);
   } catch (Error e) {
     return null;
   }
 }
예제 #2
0
  public static CtClass makeInvocationClassNoCtors(
      AOPClassPool pool,
      boolean makeInnerClass,
      CtClass outerClass,
      String className,
      CtClass superInvocation)
      throws CannotCompileException, NotFoundException {
    CtClass untransformable = pool.get("org.jboss.aop.instrument.Untransformable");

    CtClass invocation;
    if (makeInnerClass) {
      // Strip away the package from classname
      String innerClassName = className.substring(className.lastIndexOf('.') + 1);
      defrostClassIfExists(pool, outerClass.getName() + "$" + innerClassName);

      // Only static nested classes are supported
      boolean classStatic = true;
      invocation = TransformerCommon.makeNestedClass(outerClass, innerClassName, classStatic);
      invocation.setSuperclass(superInvocation);
    } else {
      defrostClassIfExists(pool, className);
      invocation = TransformerCommon.makeClass(pool, className, superInvocation);
    }

    invocation.addInterface(untransformable);
    return invocation;
  }
예제 #3
0
 public static void defrostClassIfExists(AOPClassPool pool, String className) {
   // In some cases we get a class frozen exception. I guess if the invocation class
   // existed, method was unwrapped and the wrapped again
   CtClass existing = pool.getCached(className);
   if (existing != null) {
     existing.defrost();
   }
 }
  public byte[] translate(
      AspectManager manager, String className, ClassLoader loader, byte[] classfileBuffer)
      throws Exception {
    if (isReEntry()) {
      return null;
    }
    setReEntry();
    super.setTransformationStarted();
    try {
      if (manager.isNonAdvisableClassName(className)) {
        return null;
      }

      AOPClassPool pool = (AOPClassPool) manager.registerClassLoader(loader);

      CtClass clazz = obtainCtClassInfo(pool, className, classfileBuffer);

      CtClass woven = instrumentClass(manager, pool, clazz, true);
      if (woven != null) {
        pool.lockInCache(woven);
        if (AspectManager.debugClasses) {
          SecurityActions.debugWriteFile(clazz);
        }
        byte[] rtn = woven.toBytecode();
        if (AspectManager.getPrune()) woven.prune();
        return rtn;
      } else {
        pool.soften(clazz);
      }
      return null;
    } catch (Exception ex) {
      if (!(ex instanceof NotFoundException)) {
        if (verbose) logger.error(ex);
        else logger.error(ex.getMessage() + ".. Do verbose mode if you want full stack trace.");
      }
      throw ex;
    } finally {
      clearReEntry();
    }
  }
예제 #5
0
 @Override
 public void lockInCache(CtClass clazz) {
   super.lockInCache(clazz);
   localResources.put(getResourceName(clazz.getName()), Boolean.TRUE);
 }
  private CtClass instrumentClass(
      AspectManager manager, AOPClassPool pool, CtClass clazz, boolean isLoadedClass)
      throws NotFoundException, Exception {
    if (pool.isClassLoadedButNotWoven(clazz.getName())) {
      return null;
    }
    try {
      CtClass superClass = clazz.getSuperclass();
      if (superClass != null && !Instrumentor.implementsAdvised(clazz)) {
        ClassPool superPool = superClass.getClassPool();
        if (superPool instanceof AOPClassPool) {
          AspectManager aspectManager = manager;
          if (manager instanceof Domain && superPool != pool) {
            // We are in a scoped classloader and the superclass is not
            aspectManager = AspectManager.instance(superPool.getClassLoader());
          }
          instrumentClass(aspectManager, (AOPClassPool) superPool, superClass, false);
        }
      }

      if (manager.isNonAdvisableClassName(clazz.getName())) {
        return null;
      }

      if (clazz.isArray()) {
        if (verbose && logger.isDebugEnabled())
          logger.debug("cannot compile, isArray: " + clazz.getName());
        pool.flushClass(clazz.getName());
        return null;
      }
      if (clazz.isInterface()) {
        if (verbose && logger.isDebugEnabled())
          logger.debug("cannot compile, isInterface: " + clazz.getName());
        // pool.flushClass(info.getClassName());
        clazz.prune();
        return null;
      }
      if (clazz.isFrozen()) {
        if (isAdvised(pool, clazz)) return null;
        if (verbose && logger.isDebugEnabled())
          logger.debug("warning, isFrozen: " + clazz.getName() + " " + clazz.getClassPool());
        if (!isLoadedClass) {
          // What's the point of this?
          clazz = obtainCtClassInfo(pool, clazz.getName(), null);
        } else return null;
        // info.getClazz().defrost();
      }

      boolean transformed = clazz.isModified();
      if (!transformed) {
        ClassAdvisor advisor = AdvisorFactory.getClassAdvisor(clazz, manager);
        Instrumentor instrumentor =
            InstrumentorFactory.getInstrumentor(
                pool,
                manager,
                manager.dynamicStrategy.getJoinpointClassifier(),
                manager.dynamicStrategy.getDynamicTransformationObserver(clazz));

        if (!Instrumentor.isTransformable(clazz)) {
          if (verbose && logger.isDebugEnabled())
            logger.debug("cannot compile, implements Untransformable: " + clazz.getName());
          // Flushing the generated invocation classes breaks things further down the line
          // pool.flushClass(info.getClassName());
          return null;
        }

        manager.attachMetaData(advisor, clazz, true);
        manager.applyInterfaceIntroductions(advisor, clazz);
        transformed = instrumentor.transform(clazz, advisor);
      }
      if (transformed) {
        return clazz;
      }

      if (isLoadedClass) {
        pool.setClassLoadedButNotWoven(clazz.getName());
      }

      return null;
    } catch (Exception e) {
      throw new RuntimeException("Error converting class ", e);
    } finally {
    }
  }