public static void main(String... args) {
    classPool = new ClassPool();
    classPool.importPackage("java.sql");
    classPool.appendClassPath(new LoaderClassPath(JavassistProxyFactory.class.getClassLoader()));

    try {
      // Cast is not needed for these
      String methodBody =
          "{ try { return delegate.method($$); } catch (SQLException e) { throw checkException(e); } }";
      generateProxyClass(Connection.class, ConnectionProxy.class.getName(), methodBody);
      generateProxyClass(Statement.class, StatementProxy.class.getName(), methodBody);
      generateProxyClass(ResultSet.class, ResultSetProxy.class.getName(), methodBody);

      // For these we have to cast the delegate
      methodBody =
          "{ try { return ((cast) delegate).method($$); } catch (SQLException e) { throw checkException(e); } }";
      generateProxyClass(
          PreparedStatement.class, PreparedStatementProxy.class.getName(), methodBody);
      generateProxyClass(
          CallableStatement.class, CallableStatementProxy.class.getName(), methodBody);

      modifyProxyFactory();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  public JavassistInstrumentingClassLoader(
      ClassLoader classLoader,
      ClassCache classCache,
      AndroidTranslator androidTranslator,
      Setup setup) {
    super(classLoader, null);
    this.setup = setup;

    for (String className : setup.getClassesToDelegateFromRcl()) {
      delegateLoadingOf(className);
    }

    this.classCache = classCache;
    try {
      ClassPool classPool = new ClassPool();
      classPool.appendClassPath(new LoaderClassPath(classLoader));

      if (classLoader != JavassistInstrumentingClassLoader.class.getClassLoader()) {
        classPool.appendClassPath(
            new LoaderClassPath(JavassistInstrumentingClassLoader.class.getClassLoader()));
      }

      addTranslator(classPool, androidTranslator);
    } catch (NotFoundException e) {
      throw new RuntimeException(e);
    } catch (CannotCompileException e) {
      throw new RuntimeException(e);
    }
  }
  public static boolean start(RootDoc rootDoc) throws Exception {
    List<Class<?>> mbeanIspnClasses = getMBeanClasses();
    List<Class<?>> globalClasses = new ArrayList<Class<?>>();
    List<Class<?>> namedCacheClasses = new ArrayList<Class<?>>();
    for (Class<?> clazz : mbeanIspnClasses) {
      Scope scope = clazz.getAnnotation(Scope.class);
      if (scope != null && scope.value() == Scopes.GLOBAL) {
        debug("Add as global class " + clazz);
        globalClasses.add(clazz);
      } else {
        debug("Add as named cache class " + clazz);
        namedCacheClasses.add(clazz);
      }
    }

    // Init the Javassist class pool.
    classPool = ClassPool.getDefault();
    classPool.insertClassPath(new ClassClassPath(RhqPluginXmlGenerator.class));
    PluginGen pg = new PluginGen();

    Props root = new Props();
    root.setPluginName("Infinispan");
    root.setPluginDescription("Supports management and monitoring of Infinispan");
    root.setName("Infinispan Cache Manager");
    root.setPkg("org.infinispan.rhq");
    root.setDependsOnJmxPlugin(true);
    root.setDiscoveryClass("CacheManagerDiscovery");
    root.setComponentClass("CacheManagerComponent");
    root.setSingleton(false);
    root.setCategory(ResourceCategory.SERVICE);
    Set<TypeKey> servers = new HashSet<TypeKey>();
    servers.add(new TypeKey("JMX Server", "JMX"));
    servers.add(new TypeKey("JBossAS Server", "JBossAS"));
    servers.add(new TypeKey("JBossAS Server", "JBossAS5"));
    root.setRunsInsides(servers);
    populateMetricsAndOperations(globalClasses, root, false);

    Props cache = new Props();
    cache.setName("Infinispan Cache");
    cache.setPkg("org.infinispan.rhq");
    cache.setDependsOnJmxPlugin(true);
    cache.setDiscoveryClass("CacheDiscovery");
    cache.setComponentClass("CacheComponent");
    cache.setSingleton(false);
    cache.setCategory(ResourceCategory.SERVICE);
    populateMetricsAndOperations(namedCacheClasses, cache, true);

    root.getChildren().add(cache);

    String metaInfDir = "../../../src/main/resources/META-INF";
    new File(metaInfDir).mkdirs();
    String targetMetaInfDir = "../../../target/classes/META-INF";
    new File(targetMetaInfDir).mkdirs();

    pg.createFile(root, "descriptor", "rhq-plugin.xml", metaInfDir);
    copyFile(
        new File(metaInfDir + "/rhq-plugin.xml"), new File(targetMetaInfDir + "/rhq-plugin.xml"));

    return true;
  }
Beispiel #4
0
 /*  66:    */
 /*  67:    */ private boolean matchClass(String name, ClassPool pool) /*  68:    */ {
   /*  69: 84 */ if (this.classname.equals(name)) {
     /*  70: 85 */ return true;
     /*  71:    */ }
   /*  72:    */ try
   /*  73:    */ {
     /*  74: 88 */ CtClass clazz = pool.get(name);
     /*  75: 89 */ CtClass declClazz = pool.get(this.classname);
     /*  76: 90 */ if (clazz.subtypeOf(declClazz)) {
       /*  77:    */ try
       /*  78:    */ {
         /*  79: 92 */ CtMethod m = clazz.getMethod(this.methodname, this.methodDescriptor);
         /*  80: 93 */ return m.getDeclaringClass().getName().equals(this.classname);
         /*  81:    */ }
       /*  82:    */ catch (NotFoundException e)
       /*  83:    */ {
         /*  84: 97 */ return true;
         /*  85:    */ }
       /*  86:    */ }
     /*  87:    */ }
   /*  88:    */ catch (NotFoundException e)
   /*  89:    */ {
     /*  90:101 */ return false;
     /*  91:    */ }
   /*  92:104 */ return false;
   /*  93:    */ }
Beispiel #5
0
  private Object[] extractParams(Mapping mapping, HttpServletRequest request) {
    Object[] params;

    ClassPool pool = ClassPool.getDefault();

    pool.insertClassPath(new ClassClassPath(mapping.clazz));

    CtMethod cm = null;
    CtClass[] parameterTypes = new CtClass[0];
    try {
      cm = pool.get(mapping.clazz.getName()).getDeclaredMethod(mapping.method.getName());
      parameterTypes = cm.getParameterTypes();
    } catch (NotFoundException e) {
      e.printStackTrace();
    }

    if (0 == parameterTypes.length) return new Object[0];

    params = new Object[parameterTypes.length];

    LocalVariableAttribute attr =
        (LocalVariableAttribute)
            cm.getMethodInfo().getCodeAttribute().getAttribute(LocalVariableAttribute.tag);
    int pos = Modifier.isStatic(cm.getModifiers()) ? 0 : 1;
    for (int i = 0; i < params.length; i++) {
      String name = attr.variableName(i + pos);
      String typeName = parameterTypes[i].getName();

      Binder binder = Binder.valueOf(typeName);
      Object param = binder.get(name, request, mapping);
      params[i] = param;
    }

    return params;
  }
  // TODO: Implement byte code instrumentation to replace calls to methods that do not exist in
  // proxy by invoke(callee,methodHash/methodName,args)
  protected void instrument(
      CtClass toManipulate,
      String extRef,
      ClassPool externalPool,
      String proxyName,
      ProxyLoader loader)
      throws NotFoundException, CannotCompileException {
    ClassPool proxyPool = getPool(externalPool, loader);
    // javassist bytecode manipulation

    // LOG.info(" onWrite: getting proxy "+proxyName+" from pool "+loader.getClassPath());
    CtClass proxyCtClass = proxyPool.get(proxyName);
    // LOG.info(" onWrite: getting external class "+extRef+" from pool "+extCop.getClassPath());
    CtClass extRefCtClass = externalPool.get(extRef);
    if (proxyCtClass.getSuperclass() == extRefCtClass) {
      CodeConverter conv = new CodeConverter();

      conv.replaceNew(extRefCtClass, proxyCtClass, TransparentProxyFactory.factoryMethod);
      // replace any occurence of "new $extRefClass ()" by "$proxyClass.$factoryMathod" in code of
      // $className
      toManipulate.instrument(conv);
      // e.g. "new TestComponentMain()" is replaced by
      // "Proxy4_TestComponentMain.newExternalInstance()" in bytecode of class
      // "ComponentUsingAnotherOne"
      // LOG.info(" Finished bytecode instrumentation of "+toManipulate.getName());
    }
  }
  @Override
  public void describeTo(StringBuilder stringBuilder) {
    ClosureUtil.SourceInfo sourceInfo = ClosureUtil.getSourceInfo(invoker.getClosure());
    if (sourceInfo == null) {
      ClassPool pool = ClassPool.getDefault();
      try {
        CtClass ctClass = pool.get(invoker.getClosure().getClass().getName());
        CtMethod ctMethod = ctClass.getDeclaredMethod("doCall");
        int lineNumber = ctMethod.getMethodInfo().getLineNumber(0);

        ClassFile classFile = ctClass.getClassFile();
        String sourceFile = classFile.getSourceFile();

        if (lineNumber != -1 && sourceFile != null) {
          stringBuilder
              .append("closure at line ")
              .append(lineNumber)
              .append(" of ")
              .append(sourceFile);
        } else {
          stringBuilder.append("closure ").append(invoker.getClosure().getClass().getName());
        }
      } catch (NotFoundException e) {
        stringBuilder.append(invoker.getClosure().getClass().getName());
      }
    } else {
      stringBuilder
          .append("closure at line ")
          .append(sourceInfo.getLineNumber())
          .append(" of ")
          .append(sourceInfo.getUri());
    }
  }
  public void first(Set<String> classNames) throws NotFoundException, ClassNotFoundException {
    // 扫描注册
    ClassPool classPool = ClassPool.getDefault();
    String tempClassName = null;
    Class register = Register.class;
    CtClass clazz;
    Object isRegister;
    Iterator<String> it = classNames.iterator();
    while (it.hasNext()) {
      tempClassName = it.next();
      clazz = classPool.get(tempClassName);
      isRegister = clazz.getAnnotation(register);

      AnnotationsAttribute a =
          (AnnotationsAttribute)
              clazz.getClassFile2().getAttribute(AnnotationsAttribute.visibleTag);
      Annotation[] as = a.getAnnotations();
      for (Annotation an : as) {
        //				System.out.println(String.format("MemberNames:%s ", an.getMemberNames()));
        Set anSet = an.getMemberNames();
        Iterator anit = anSet.iterator();
        while (anit.hasNext()) {
          System.out.println("type:" + anit.next().getClass());
        }
        //			AnnotationsAttribute a = (AnnotationsAttribute)
        // clazz.getClassFile().getAttribute(AnnotationsAttribute.visibleTag);
        //				for()
      }
      System.err.println(a);
      System.err.println(a);
      //			System.err.println(a.getName());

      if (null != isRegister) System.out.println(isRegister);
    }
  }
Beispiel #9
0
  /** @param filePath */
  private static void execute(File file, String pkg, String path) {
    String fl = file.getName();
    Pattern pt = Pattern.compile(".*\\.class$");
    Matcher mc = pt.matcher(fl);
    if (mc.matches()) {
      fl = fl.replaceAll("\\.class", "");
      try {
        ClassPool cp = ClassPool.getDefault();
        cp.appendClassPath(path);

        CtClass targetClass = cp.get(pkg + fl);

        System.out.println(targetClass.getName());
        Object[] annList = targetClass.getAnnotations();
        for (Object ann : annList) {
          if (ann instanceof MethodList) {
            classList.add(targetClass);
            target = targetClass;
          } else if (ann instanceof TargetClass) {
            targetList.add(targetClass);
          }
        }
      } catch (Exception ex) {
        ex.printStackTrace();
      }
    }
  }
 private static ClassPool configureClassPool() {
   final ClassPool classPool = new ClassPool(ClassPool.getDefault());
   classPool.appendClassPath(new LoaderClassPath(Thread.currentThread().getContextClassLoader()));
   classPool.appendClassPath(new LoaderClassPath(ClassLoader.getSystemClassLoader()));
   classPool.importPackage("com.lmax.tool.disruptor");
   return classPool;
 }
  /**
   * Similar to main method but is not static
   *
   * @param args command line parameters
   * @throws Exception if something fails during the execution
   */
  public void doIt2(String[] args) throws Exception {

    // Se carga la clase para la que se quiere modificar sus bytecodes
    ClassPool pool = ClassPool.getDefault();
    CtClass cc = pool.get("com.jzb.ja.Clase1");

    // Se puede iterar imprimiendo los metodos, y su signatura, contenidos en la clase
    for (CtMethod mm : cc.getMethods()) {
      System.out.println(mm.getName() + " " + mm.getMethodInfo().getDescriptor());
    }

    // Se puede buscar un metodo en concreto...
    CtMethod mr = cc.getMethod("diHola", "(Ljava/lang/String;)Ljava/lang/String;");
    // ... Borrarlo...
    cc.removeMethod(mr);
    // .. Y volver a escribir su .class moficado en una carpeta raiz
    cc.writeFile("c:\\tmp");

    // Posteriormente, tanto por este codigo de creación dinamica, o porque se usa
    // el fichero .class generado antes, se obtiene un error de "Metodo No Existe"
    Class c1 = cc.toClass();
    Clase1 o1 = (Clase1) c1.newInstance();
    System.out.println(o1.sumaUno(2));
    System.out.println(o1.diHola("Pepe"));
  }
  public T createJavassistProxy(
      LoadBalancer loadBalance, ConcurrentMap<String, T> map, Class ifaces) throws Exception {

    Class<?>[] interfaces = ifaces.getInterfaces();

    if (interfaces.length == 1) {
      ClassPool mPool = new ClassPool(true);
      CtClass ctClass = mPool.get(interfaces[0].getName());

      // 新建代理类
      CtClass mCtc = mPool.makeClass(ifaces.getName() + "$JavassistProxy");
      mCtc.setSuperclass(ctClass);

      for (CtMethod method : ctClass.getDeclaredMethods()) {
        System.out.println(method.getName());

        //                CtMethod m = new CtMethod(method.getReturnType(),
        // ,method.getParameterTypes(), mCtc);
        //                cc.addMethod(m);
        //                m.setBody("{ x += $1; }");

        mCtc.addMethod(method);
        //                method.setBody("");

      }
      //            mCtc.debugWriteFile("/home/liguojun");

      return null;
    } else {
      return null;
    }
  }
  //    @Test
  public void ctClassName() throws NotFoundException {
    ClassPool pool = new ClassPool(true);

    CtClass ctClass = pool.get("java.lang.String");
    logger.info("ctClass:{}", ctClass);
    logger.info("ctClass:{}", ctClass.getName());
    logger.info("ctClass:{}", ctClass.getSimpleName());
  }
 /**
  * Verify that CtField is exactly the java.util.Collection, java.util.List or java.util.Set,
  * otherwise cannot instrument the class' field
  */
 private boolean isCtFieldACollection(CtField ctField) {
   try {
     return ctField.getType().equals(cp.get(Collection.class.getName()))
         || ctField.getType().equals(cp.get(List.class.getName()))
         || ctField.getType().equals(cp.get(Set.class.getName()));
   } catch (NotFoundException e) {
     e.printStackTrace();
     return false;
   }
 }
  private Class<?> injectToPlainClassLoader(ClassLoader classLoader, String className)
      throws NotFoundException, IllegalArgumentException, IOException, CannotCompileException,
          IllegalAccessException, InvocationTargetException {
    ClassPool pool = new ClassPool();

    pool.appendClassPath(new LoaderClassPath(classLoader));
    pool.appendClassPath(pluginJar.getName());

    return injectToPlainClassLoader(pool, classLoader, className);
  }
 /**
  * Instruments the given directory, reading each .class file, processing it, and writing it back
  * to the filesystem
  *
  * @param configurer an {@link InstrumenterConfigurer} that will setup the actual {@link
  *     Instrumenter} that will be used to process the directory
  * @param processDirectory the directory with .class files to process
  * @param extraPath a string containing a list of additional paths to add to the classpath used on
  *     instrumentation. This string is system-dependent, using the platform separator and
  *     directory separator
  * @throws Exception
  * @see File#pathSeparator
  * @see File#separator
  */
 public static void runInstrumentation(
     @NonNull InstrumenterConfigurer configurer,
     @NonNull Directory processDirectory,
     @NonNull String extraPath)
     throws Exception {
   ClassPool classPool = new ClassPool(true);
   classPool.appendPathList(extraPath);
   classPool.appendClassPath(processDirectory.getAbsolutePath());
   InstrumenterImpl instrumenter = new InstrumenterImpl(classPool);
   configurer.configureInstrumenter(instrumenter);
   instrumenter.ensureConfigured();
   new InstrumentationContext(instrumenter, processDirectory, classPool).doInstrument();
 }
Beispiel #17
0
 // not used anymore.
 private void notTestGetInner() throws Exception {
   ClassPool pool = ClassPool.getDefault();
   CtClass c = pool.get("javassist.CtMethod.ConstParameter");
   CtClass d = pool.get("javassist.CtMethod.ConstParameter");
   CtClass e = pool.get("javassist.CtMethod$ConstParameter");
   assertSame(c, d);
   assertSame(c, e);
   try {
     c = pool.get("test2.Inner.Fake");
     fail("found not-existing class");
   } catch (NotFoundException ex) {
   }
 }
 protected ClassPool getPool(ClassPool externalPool, ProxyLoader loader) throws NotFoundException {
   ClassPool proxyPool;
   // TODO Cheating here by mapping the ProxyLoader instead of the ProxyResource. But have to
   // change that as soon as ProxyResource initCL() sets ProxyLoader itself
   Object cached = cop2pool.get(loader);
   if (cached instanceof ClassPool) {
     proxyPool = (ClassPool) cached;
   } else {
     proxyPool = ClassPool.getDefault();
     proxyPool.appendClassPath(loader.getClassPath());
     cop2pool.put(loader, externalPool);
   }
   return proxyPool;
 }
Beispiel #19
0
  public void not_testURLClassPath() throws Exception {
    String host = "www.csg.is.titech.ac.jp";
    String path = "/~chiba/tmp/";
    String url;

    ClassPool cp = new ClassPool(null);
    cp.insertClassPath(new URLClassPath(host, 80, path, "test"));

    url = cp.find("test.TestClassPath").toString();
    System.out.println(url);
    assertEquals("http://" + host + ":80" + path + "test/TestClassPath.class", url);

    assertNull(cp.find("test.No"));
  }
  /** initial creation of the class EnergyData and associated elements in the robot */
  public static void update(ClassPool pool, CtClass robot)
      throws CannotCompileException, RuntimeException, NotFoundException {

    CtClass pgui = pool.get("fr.upmc.dtgui.gui.PersonalizedGUI");

    // method createBoard
    CtMethod cb = pool.getMethod("fr.upmc.dtgui.gui.PersonalizedGUI", "createBoard");
    cb.setBody(
        "{\n"
            + "fr.upmc.dtgui.gui.RobotTeleoperationBoard board;\n"
            + "board = new "
            + robot.getName()
            + "TeleoperationBoard($0, $0.sizeX - 50);\n"
            + "return board ;\n"
            + "}\n");

    // method createSensorDataReceptor
    CtMethod csdr = pool.getMethod("fr.upmc.dtgui.gui.PersonalizedGUI", "createSensorDataReceptor");
    csdr.setBody(
        "{\n"
            + "fr.upmc.dtgui.gui.SensorDataReceptorInterface sdr = null ;\n"
            + "sdr = $2.makeSensorDataReceptor("
            + "$0.positionDisplay, $1.getSensorDataQueue(),"
            + "$0.absoluteX, $0.absoluteY, $0.controlRadius"
            + ") ;\n"
            + "return sdr ;\n"
            + "}\n");

    // method detectRobot
    CtMethod dr =
        new CtMethod(
            CtClass.voidType,
            "detectRobot",
            new CtClass[] {pool.get("fr.upmc.dtgui.robot.InstrumentedRobot")},
            pgui);
    dr.setBody(
        "{\n"
            + "fr.upmc.dtgui.gui.RobotTeleoperationBoard board = null ;\n"
            + "fr.upmc.dtgui.gui.SensorDataReceptorInterface sdr = null ;\n"
            + "if (!this.detected($1)) {\n"
            + "board = $0.createBoard($1) ;\n"
            + "sdr = $0.createSensorDataReceptor($1, board) ;\n"
            + "$0.sensors.put($1, sdr) ;\n"
            + "$0.boards.put($1, board) ;\n"
            + "sdr.start() ;\n"
            + "this.validate() ;\n"
            + "}\n"
            + "}\n");
    pgui.addMethod(dr);
  }
 private static boolean isCtClassSerializable(
     JarArchiveComparatorOptions options,
     CtClass clazz,
     JarArchiveComparator jarArchiveComparator) {
   ClassPool pool = clazz.getClassPool();
   try {
     return clazz.subtypeOf(pool.get("java.io.Serializable"));
   } catch (NotFoundException e) {
     if (options.isIgnoreMissingClasses()) {
       return false;
     } else {
       throw JApiCmpException.forClassLoading(e, clazz.getName(), jarArchiveComparator);
     }
   }
 }
 protected ClassPool getPool(UpgradeableComponentResource extCop) throws NotFoundException {
   //	create a pool for every dependency component with external classes
   ClassPool externalPool;
   Object cached = cop2pool.get(extCop);
   if (cached instanceof ClassPool) {
     externalPool = (ClassPool) cached;
   } else {
     externalPool = ClassPool.getDefault();
     String path = extCop.getExtResLocation() + extCop.getCodeBase();
     externalPool.appendClassPath(path);
     // LOG.info(" Creating a ClassPool for dependency Component at "+path);
     cop2pool.put(extCop, externalPool);
   }
   return externalPool;
 }
Beispiel #23
0
  public void testInheritance() throws Exception {
    ClassPool pool = ClassPool.getDefault();
    String classname = "test2.Inherit";
    CtClass target = pool.get(classname);
    String src =
        "public void sampleMethod() {"
            + "  test2.Inherit i = new test2.Inherit();"
            + "  test2.Inherit2 i2 = i;"
            + "  test2.Inherit3 i3 = i;"
            + "  i3.foo2(); i3.foo2(); i2.foo1(); }";

    CtMethod newmethod = CtNewMethod.make(src, target);
    target.addMethod(newmethod);
    target.writeFile();
  }
  static TypeParameterMatcher generate(Class<?> type, ClassLoader classLoader) {
    final String className = "io.netty.util.internal.__matchers__." + type.getName() + "Matcher";
    try {
      try {
        return (TypeParameterMatcher) Class.forName(className, true, classLoader).newInstance();
      } catch (Exception e) {
        // Not defined in the specified class loader.
      }

      CtClass c = classPool.getAndRename(NoOpTypeParameterMatcher.class.getName(), className);
      c.setModifiers(c.getModifiers() | Modifier.FINAL);
      c.getDeclaredMethod("match").setBody("{ return $1 instanceof " + type.getName() + "; }");
      byte[] byteCode = c.toBytecode();
      c.detach();
      Method method =
          ClassLoader.class.getDeclaredMethod(
              "defineClass", String.class, byte[].class, int.class, int.class);
      method.setAccessible(true);

      Class<?> generated =
          (Class<?>) method.invoke(classLoader, className, byteCode, 0, byteCode.length);
      logger.debug("Generated: {}", generated.getName());
      return (TypeParameterMatcher) generated.newInstance();
    } catch (RuntimeException e) {
      throw e;
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
Beispiel #25
0
  private void addOutputArg(List<String> args, Object object) {
    if (!(object instanceof String))
      throw new IllegalArgumentException("Only a single output file can be specified");

    String value = (String) object;
    args.add("-o");
    if (value.endsWith(".vcf")) {
      args.add(value);
      try {
        ConstPool constPool = annotatedWalker.getClassFile().getConstPool();
        AnnotationsAttribute att =
            new AnnotationsAttribute(constPool, AnnotationsAttribute.visibleTag);
        Annotation ann = new Annotation(Output.class.getName(), constPool);
        att.addAnnotation(ann);

        CtClass writerClass = pool.get(VCFWriter.class.getName());
        CtField field = new CtField(writerClass, "out", annotatedWalker);
        field.setModifiers(Modifier.PUBLIC);
        field.getFieldInfo().addAttribute(att);
        annotatedWalker.addField(field);
      } catch (NotFoundException e) {
        throw new RuntimeException(e);
      } catch (CannotCompileException e) {
        throw new RuntimeException(e);
      }
    } else throw new IllegalArgumentException("Only VCF files are supported as output files");
  }
 static {
   try {
     OBJECT_CLASS = ClassPool.getDefault().get(Object.class.getName());
   } catch (NotFoundException e) {
     throw new RuntimeException(e);
   }
 }
  /* (non-Javadoc)
   * @see javassist.Translator#onWrite(javassist.ClassPool, java.lang.String)
   */
  public void onWrite(ClassPool pool, String classname)
      throws NotFoundException, CannotCompileException {

    // LOG.info(++logCounter+" Searching component for "+classname+" in repository with #cop =
    // "+ComponentRepository.Instance().getComponentResources().size());
    //  COMPONENT MUST HAVE BEEN PUT IN REPOSITORY MAP ALREADY (before initComponent())
    IComponentResource loadingCop =
        UpgradeableComponentResourceFactory.getComponentResourceByContent(classname);

    /* DEBUGGING ONLY: check if have to load from dependency: // MUST NOT happen: load from wrong cop!!!
    if (loadingCop == null) {
    	LOG.error(cp+" "+v+": class "+classname+" belongs to no cop ");
    	return;
    } else if( !((UpgradeableComponentResource)loadingCop).contains(classname))  {
    	// wrong cop: hack , check for loadingCop.knowsClass(classname) instead
    	LOG.error(cp+" "+v+": class "+classname+" belongs not to cop "+loadingCop);
    	return;

    }*/
    String cb = ProxyComponentResourceFactory.getProxyCodebase(loadingCop);
    IComponentResource proxyCop = ComponentRepository.Instance().getComponentResourceByCodebase(cb);
    if (proxyCop instanceof ProxyComponentResource) {
      // during an upgrade, check if current version of cop was retreived
      loadingCop = ((ProxyComponentResource) proxyCop).getOriginalComponent();
    }

    // LOG.info(loadingCop+", "+loadingCop.getVersion()+": pool.get("+classname+")");
    // if (loadingCop instanceof ProxyComponentResource) return;

    int extRefCount = searchExternalReferences(classname, pool, loadingCop);
    if (extRefCount == 0) return;
    CtClass toManipulate = pool.get(classname);
    manipulate(classname, toManipulate, extRefCount);
  }
 @After
 public void tearDown() throws Exception {
   final CtClass packageInfoCtClass =
       ClassPool.getDefault().get("com.edugility.jaxb.package-info");
   assertNotNull(packageInfoCtClass);
   packageInfoCtClass.detach();
 }
 public void appendClassPath(String classPath) {
   try {
     classPool.appendClassPath(classPath);
   } catch (NotFoundException e) {
     throw new IllegalStateException(e);
   }
 }
 @Override
 protected void cacheCtClass(String className, CtClass c, boolean dynamic) {
   if (isSrg && !exclude(className)) {
     return;
   }
   super.cacheCtClass(className, c, dynamic);
 }