Examples with UnmodifiableClassException java.lang.instrument.UnmodifiableClassException used on opensource projects

Example 6 with UnmodifiableClassException

use of java.lang.instrument.UnmodifiableClassException in project fakereplace by fakereplace.

the class MainTransformer method transform.

@Override
public byte[] transform(final ClassLoader loader, final String className, final Class<?> classBeingRedefined, final ProtectionDomain protectionDomain, final byte[] classfileBuffer) throws IllegalClassFormatException {
    if (className == null) {
        // TODO: deal with lambdas
        return classfileBuffer;
    }
    boolean replaceable = Fakereplace.isClassReplaceable(className, loader);
    if (classBeingRedefined != null) {
        retransformationStarted = true;
        if (logClassRetransformation && replaceable) {
            log.info("Fakereplace is replacing class " + className);
        }
    }
    ChangedClassImpl changedClass = null;
    if (classBeingRedefined != null) {
        changedClass = new ChangedClassImpl(classBeingRedefined);
    }
    boolean changed = false;
    if (!replaceable && UnmodifiedFileIndex.isClassUnmodified(className)) {
        return null;
    }
    Set<Class<?>> classesToRetransform = new HashSet<>();
    final ClassFile file;
    try {
        Set<MethodInfo> modifiedMethods = new HashSet<>();
        file = new ClassFile(new DataInputStream(new ByteArrayInputStream(classfileBuffer)));
        for (final FakereplaceTransformer transformer : transformers) {
            if (transformer.transform(loader, className, classBeingRedefined, protectionDomain, file, classesToRetransform, changedClass, modifiedMethods)) {
                changed = true;
            }
        }
        if (!changed) {
            UnmodifiedFileIndex.markClassUnmodified(className);
            return null;
        } else {
            try {
                if (!modifiedMethods.isEmpty()) {
                    ClassPool classPool = new ClassPool();
                    if (loader == null) {
                        classPool.appendClassPath(new LoaderClassPath(ClassLoader.getSystemClassLoader()));
                    } else {
                        classPool.appendClassPath(new LoaderClassPath(loader));
                    }
                    classPool.appendSystemPath();
                    for (MethodInfo method : modifiedMethods) {
                        if (method.getCodeAttribute() != null) {
                            method.getCodeAttribute().computeMaxStack();
                            try {
                                method.rebuildStackMap(classPool);
                            } catch (BadBytecode e) {
                                Throwable root = e;
                                while (!(root instanceof NotFoundException) && root != null && root.getCause() != root) {
                                    root = root.getCause();
                                }
                                if (root instanceof NotFoundException) {
                                    NotFoundException cause = (NotFoundException) root;
                                    Bytecode bytecode = new Bytecode(file.getConstPool());
                                    bytecode.addNew(NoClassDefFoundError.class.getName());
                                    bytecode.add(Opcode.DUP);
                                    bytecode.addLdc(cause.getMessage());
                                    bytecode.addInvokespecial(NoClassDefFoundError.class.getName(), "<init>", "(Ljava/lang/String;)V");
                                    bytecode.add(Opcode.ATHROW);
                                    method.setCodeAttribute(bytecode.toCodeAttribute());
                                    method.getCodeAttribute().computeMaxStack();
                                    method.getCodeAttribute().setMaxLocals(DescriptorUtils.maxLocalsFromParameters(method.getDescriptor()) + 1);
                                    method.rebuildStackMap(classPool);
                                } else {
                                    throw e;
                                }
                            }
                        }
                    }
                }
            } catch (BadBytecode e) {
                throw new RuntimeException(e);
            }
            ByteArrayOutputStream bs = new ByteArrayOutputStream();
            file.write(new DataOutputStream(bs));
            // dump the class for debugging purposes
            final String dumpDir = AgentOptions.getOption(AgentOption.DUMP_DIR);
            if (dumpDir != null) {
                try {
                    File dump = new File(dumpDir + '/' + file.getName() + ".class");
                    dump.getParentFile().mkdirs();
                    FileOutputStream s = new FileOutputStream(dump);
                    DataOutputStream dos = new DataOutputStream(s);
                    file.write(dos);
                    s.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (!classesToRetransform.isEmpty()) {
                synchronized (this) {
                    retransformationOutstandingCount++;
                }
                Thread t = new Thread(() -> {
                    try {
                        Fakereplace.getInstrumentation().retransformClasses(classesToRetransform.toArray(new Class[classesToRetransform.size()]));
                    } catch (UnmodifiableClassException e) {
                        log.error("Failed to retransform classes", e);
                    } finally {
                        synchronized (MainTransformer.this) {
                            retransformationOutstandingCount--;
                            notifyAll();
                        }
                    }
                });
                t.setDaemon(true);
                t.start();
            }
            if (classBeingRedefined != null) {
                changedClasses.add(changedClass);
                queueIntegration();
            }
            return bs.toByteArray();
        }
    } catch (IOException e) {
        e.printStackTrace();
        throw new IllegalClassFormatException(e.getMessage());
    } catch (Throwable e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}

Example 7 with UnmodifiableClassException

use of java.lang.instrument.UnmodifiableClassException in project HotswapAgent by HotswapProjects.

the class HotSwapTool method toVersion.

/**
 * Redefines all inner classes of a outer class to a specified version. Inner classes who do not have a particular
 * representation for a version remain unchanged.
 *
 * @param outerClass
 *            the outer class whose inner classes should be redefined
 * @param versionNumber
 *            the target version number
 */
public static void toVersion(Class<?> outerClass, int versionNumber, Class<?>... extraClasses) {
    assert versionNumber >= 0;
    // if (versionNumber == getCurrentVersion(outerClass)) {
    // // Nothing to do!
    // return;
    // }
    Map<String, File> files = findClassesWithVersion(outerClass, versionNumber);
    for (Class<?> extra : extraClasses) {
        if (parseClassVersion(extra.getSimpleName()) == versionNumber) {
            String packageName = extra.getPackage().getName().replace('.', '/');
            URL url = extra.getClassLoader().getResource(packageName);
            if (url == null) {
                throw new IllegalArgumentException("Cannot find URL corresponding to the package '" + packageName + "'");
            }
            File file = new File(url.getFile(), extra.getSimpleName() + ".class");
            files.put(extra.getName(), file);
        }
    }
    try {
        Map<Class<?>, byte[]> map = buildRedefinitionMap(files);
        long startTime = System.currentTimeMillis();
        redefiner.redefineClasses(map);
        long curTime = System.currentTimeMillis() - startTime;
        totalTime += curTime;
        redefinitionCount++;
    } catch (UnmodifiableClassException e) {
        throw new UnsupportedOperationException(e);
    } catch (ClassNotFoundException e) {
        throw new RuntimeException("Cannot redefine classes", e);
    } catch (IOException e) {
        throw new RuntimeException("Cannot redefine classes", e);
    }
    setCurrentVersion(outerClass, versionNumber);
}

Example 8 with UnmodifiableClassException

use of java.lang.instrument.UnmodifiableClassException in project HotswapAgent by HotswapProjects.

the class InstrumentationRedefiner method redefineClasses.

public void redefineClasses(Map<Class<?>, byte[]> classes) throws ClassNotFoundException, UnmodifiableClassException {
    if (PluginManager.getInstance().getInstrumentation() == null) {
        throw new IllegalStateException("Instrumentation agent is not properly installed!");
    }
    ClassDefinition[] definitions = new ClassDefinition[classes.size()];
    int i = 0;
    for (Map.Entry<Class<?>, byte[]> entry : classes.entrySet()) {
        definitions[i++] = new ClassDefinition(entry.getKey(), entry.getValue());
        URL classResource = getClassResource(entry.getKey());
        try (OutputStream fileWriter = new FileOutputStream(new File(classResource.toURI()))) {
            fileWriter.write(entry.getValue());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    PluginManager.getInstance().getInstrumentation().redefineClasses(definitions);
}

Example 9 with UnmodifiableClassException

use of java.lang.instrument.UnmodifiableClassException in project mockito by mockito.

the class InlineBytecodeGenerator method clearAllCaches.

@Override
public synchronized void clearAllCaches() {
    Set<Class<?>> types = new HashSet<>();
    mocked.forEach(types::add);
    if (types.isEmpty()) {
        return;
    }
    mocked.clear();
    flatMocked.clear();
    try {
        instrumentation.retransformClasses(types.toArray(new Class<?>[0]));
    } catch (UnmodifiableClassException e) {
        throw new MockitoException(join("Failed to reset mocks.", "", "This should not influence the working of Mockito.", "But if the reset intends to remove mocking code to improve performance, it is still impacted."), e);
    }
}

Example 10 with UnmodifiableClassException

use of java.lang.instrument.UnmodifiableClassException in project pinpoint by naver.

the class DynamicTransformServiceTest method testRetransform_Fail_memoryleak_prevent.

@Test()
public void testRetransform_Fail_memoryleak_prevent() throws Exception {
    final Instrumentation instrumentation = mock(Instrumentation.class);
    when(instrumentation.isModifiableClass(any(Class.class))).thenReturn(true);
    doAnswer(new Answer<Void>() {

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            throw new UnmodifiableClassException();
        }
    }).when(instrumentation).retransformClasses(any(Class.class));
    DefaultDynamicTransformerRegistry listener = new DefaultDynamicTransformerRegistry();
    final ClassFileTransformer classFileTransformer = mock(ClassFileTransformer.class);
    DynamicTransformService dynamicTransformService = new DynamicTransformService(instrumentation, listener);
    try {
        dynamicTransformService.retransform(String.class, classFileTransformer);
        Assert.fail("expected retransform fail");
    } catch (Exception e) {
    }
    Assert.assertEquals(listener.size(), 0);
}