Esempio n. 1
0
  private byte[] tryTransform(
      byte[] buffer,
      String name,
      ClassLoader loader,
      String key,
      boolean isInterface,
      boolean isOverride) {
    List<RuleScript> ruleScripts;

    if (isInterface) {
      ruleScripts = scriptRepository.scriptsForInterfaceName(key);
    } else {
      ruleScripts = scriptRepository.scriptsForClassName(key);
    }
    byte[] newBuffer = buffer;

    if (ruleScripts != null) {
      //            if (isVerbose()) {
      //                System.out.println("tryTransform : " + name + " for " + key);
      //            }
      int counter = 0;

      for (RuleScript ruleScript : ruleScripts) {
        try {
          // we only transform via isOverride rules if isOverride is true
          // we tarsnform via any matchign rules if isOverride is false
          if (!isOverride || ruleScript.isOverride()) {
            // only do the transform if the script has not been deleted
            synchronized (ruleScript) {
              if (!ruleScript.isDeleted()) {
                maybeDumpClassIntermediate(name, newBuffer);
                newBuffer = transform(ruleScript, loader, name, newBuffer);
              }
            }
          }
        } catch (Throwable th) {
          // yeeeurgh I know this looks ugly with no rethrow but it is appropriate
          // we do not want to pass on any errors or runtime exceptions
          // if a transform fails then we should still allow the load to continue
          // with whatever other transforms succeed. we tarce the throwable to
          // System.err just to ensure it can be seen.

          System.err.println("Transformer.transform : caught throwable " + th);
          th.printStackTrace(System.err);
        }
      }
    }
    return newBuffer;
  }
 private static void resetLambdaClassSequenceNumber() {
   try {
     Field counterField =
         Class.forName("java.lang.invoke.InnerClassLambdaMetafactory").getDeclaredField("counter");
     counterField.setAccessible(true);
     AtomicInteger counter = (AtomicInteger) counterField.get(null);
     counter.set(0);
   } catch (Throwable t) {
     // print to stdout to keep in sync with other log output
     System.out.println(
         "WARNING: Failed to start class numbering from one. Don't worry, it's cosmetic, "
             + "but please file a bug report and tell on which JDK version this happened.");
     t.printStackTrace(System.out);
   }
 }
Esempio n. 3
0
  private static void dumpClass(String fullName, byte[] bytes, boolean intermediate) {
    // wrap this in a try catch in case the file i/o code generates a runtime exception
    // this may happen e.g. because of a security restriction
    try {
      int dotIdx = fullName.lastIndexOf('.');

      String name = (dotIdx < 0 ? fullName : fullName.substring(dotIdx + 1));
      String prefix = (dotIdx > 0 ? File.separator + fullName.substring(0, dotIdx) : "");
      String dir = getDumpGeneratedClassesDir() + prefix.replace('.', File.separatorChar);
      if (!ensureDumpDirectory(dir)) {
        System.out.println(
            "org.jboss.byteman.agent.Transformer : Cannot dump transformed bytes to directory "
                + dir
                + File.separator
                + prefix);
        return;
      }
      String newname;
      if (intermediate) {
        int counter = 0;
        // add _<n> prefix until we come up with a new name
        newname = dir + File.separator + name + "_" + counter + ".class";
        File file = new File(newname);
        while (file.exists()) {
          counter++;
          newname = dir + File.separator + name + "_" + counter + ".class";
          file = new File(newname);
        }
      } else {
        newname = dir + File.separator + name + ".class";
      }
      System.out.println(
          "org.jboss.byteman.agent.Transformer : Saving transformed bytes to " + newname);
      try {
        FileOutputStream fio = new FileOutputStream(newname);
        fio.write(bytes);
        fio.close();
      } catch (IOException ioe) {
        System.out.println("Error saving transformed bytes to" + newname);
        ioe.printStackTrace(System.out);
      }
    } catch (Throwable th) {
      System.out.println(
          "org.jboss.byteman.agent.Transformer : Error saving transformed bytes for class "
              + fullName);
      th.printStackTrace(System.out);
    }
  }