feat: got the patcher working*
*only in unobfuscated environment, and I did it using hacky awfulness that will be deleted as soon as possible.
This commit is contained in:
parent
26e52da7d8
commit
bc3eadea3b
4 changed files with 793 additions and 33 deletions
|
@ -1,27 +1,33 @@
|
|||
package bscv.asm;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import bscv.asm.api.AnnotationChecker;
|
||||
import bscv.asm.util.ClassPath22;
|
||||
import bscv.asm.api.annotations.Inject;
|
||||
import bscv.asm.api.annotations.Patch;
|
||||
import com.google.common.collect.HashMultimap;
|
||||
import cpw.mods.modlauncher.api.INameMappingService;
|
||||
import cpw.mods.modlauncher.serviceapi.ILaunchPluginService;
|
||||
import net.minecraftforge.fml.common.ObfuscationReflectionHelper;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.objectweb.asm.ClassReader;
|
||||
import org.objectweb.asm.Type;
|
||||
|
||||
import cpw.mods.modlauncher.serviceapi.ILaunchPluginService;
|
||||
import org.objectweb.asm.tree.ClassNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
|
||||
import javax.annotation.Nullable;
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.Arrays;
|
||||
import java.util.EnumSet;
|
||||
import java.util.Optional;
|
||||
import java.util.Set;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class BoSCoVicinoLoader implements ILaunchPluginService {
|
||||
|
||||
public static final String NAME = "boscovicino_asm"; //temp name
|
||||
public static final String NAME = "boscovicino_asm"; //TODO: temp name
|
||||
public static final Logger LOGGER = LogManager.getLogger("BoSCoVicinoASM");
|
||||
|
||||
private static final EnumSet<Phase> YAY = EnumSet.of(Phase.BEFORE);
|
||||
|
@ -30,6 +36,7 @@ public class BoSCoVicinoLoader implements ILaunchPluginService {
|
|||
private static final HashMultimap<String, Class<?>> patchClasses = HashMultimap.create();
|
||||
|
||||
public BoSCoVicinoLoader() {
|
||||
loadPatchesPozzed();
|
||||
LOGGER.info("BoSCoVicinoLoader instantiated successfully!");
|
||||
}
|
||||
|
||||
|
@ -40,9 +47,6 @@ public class BoSCoVicinoLoader implements ILaunchPluginService {
|
|||
|
||||
@Override
|
||||
public EnumSet<Phase> handlesClass(Type classType, final boolean isEmpty) {
|
||||
//if(!isEmpty && shouldHandle(classType))
|
||||
// LOGGER.info("CLAZZ >>> {}", classType.getClassName());
|
||||
//return NAY;
|
||||
throw new IllegalStateException("Outdated ModLauncher"); //mixin does it
|
||||
}
|
||||
|
||||
|
@ -50,99 +54,155 @@ public class BoSCoVicinoLoader implements ILaunchPluginService {
|
|||
public EnumSet<Phase> handlesClass(Type classType, final boolean isEmpty, final String reason) {
|
||||
if(isEmpty) return NAY;
|
||||
String name = classType.getClassName();
|
||||
if(name.startsWith("net.minecraft.") || name.indexOf('.') == -1)
|
||||
if(name.startsWith("net.minecraft.") || name.indexOf('.') == -1) {
|
||||
LOGGER.debug("Marked {} as to-be-handled", classType.getClassName());
|
||||
return YAY;
|
||||
} else return NAY;
|
||||
/* TODO: either bring back or delete this (probably the latter)
|
||||
else {
|
||||
try {
|
||||
if(hasAnnotation(name)) {
|
||||
Class<?> patch = Class.forName(name);
|
||||
patchClasses.put(Type.getDescriptor(patch.getAnnotation(Patch.class).value()), patch);
|
||||
return YAY;
|
||||
//patchClasses.put(patch.getAnnotation(Patch.class).value(), patch);
|
||||
//LOGGER.info("Found patch class {}", patch.getName());
|
||||
}
|
||||
} catch(IOException | ClassNotFoundException e) {
|
||||
LOGGER.debug("Could not load {}", name);
|
||||
}
|
||||
return NAY;
|
||||
}
|
||||
} */
|
||||
}
|
||||
|
||||
@Override
|
||||
public int processClassWithFlags(Phase phase, ClassNode classNode, Type classType, String reason) {
|
||||
if(patchClasses.containsKey(classType.getDescriptor())) {
|
||||
LOGGER.debug("Processing class {} in phase {} of {}", classType.getClassName(), phase.name(), reason);
|
||||
if(patchClasses.containsKey(classType.getClassName())) {
|
||||
LOGGER.info("Found class with descriptor {} among the patches", classType.getClassName());
|
||||
//can have multiple patches working on same class
|
||||
//each of these classes may attempt to patch a method one or more times
|
||||
Set<String> classMethodNames = classNode.methods
|
||||
.stream()
|
||||
.map(m -> m.name)
|
||||
.map(m -> deobfuscator(m.name))
|
||||
.collect(Collectors.toSet());
|
||||
Set<String> classMethodDescriptors = classNode.methods
|
||||
.stream()
|
||||
.map(m -> m.desc)
|
||||
.collect(Collectors.toSet());
|
||||
Set<Class<?>> relevantPatches = patchClasses.get(classType.getDescriptor());
|
||||
HashMultimap<Object, Method> patches = HashMultimap.create();
|
||||
relevantPatches
|
||||
patchClasses
|
||||
.get(classType.getClassName())
|
||||
.forEach(p -> {
|
||||
Set<Method> injectors =
|
||||
getInjectorsInPatch(p)
|
||||
.stream()
|
||||
.filter(m -> {
|
||||
Inject a = m.getAnnotation(Inject.class);
|
||||
return
|
||||
classMethodNames.contains(a.methodName())
|
||||
LOGGER.info("Found {} injector for method {}{}", m.getName(), a.methodName(), descriptorBuilder(a.returnType(), a.parameters()));
|
||||
return classMethodNames.contains(a.methodName())
|
||||
&& classMethodDescriptors.contains(descriptorBuilder(a.returnType(), a.parameters()));
|
||||
})
|
||||
.collect(Collectors.toSet());
|
||||
if(!injectors.isEmpty()) {
|
||||
try {
|
||||
patches.putAll(p.newInstance(), injectors);
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for(Method i : injectors)
|
||||
sb.append(i.getName()).append(",");
|
||||
LOGGER.info("Stored patch {} with injectors {}", p, sb.toString());
|
||||
} catch(InstantiationException | IllegalAccessException e) {
|
||||
throw new RuntimeException(e); //todo: better catch
|
||||
LOGGER.error("Something went wrong while instantiating patch {}", p);
|
||||
throw new RuntimeException(e); //todo: better error handling
|
||||
}
|
||||
}
|
||||
});
|
||||
if(patches.isEmpty())
|
||||
if(patches.isEmpty()) {
|
||||
LOGGER.info("No valid patches found for {}!", classNode.name.replace('/', '.'));
|
||||
return ComputeFlags.NO_REWRITE;
|
||||
else {
|
||||
} else {
|
||||
boolean success = false;
|
||||
for(Object p : patches.keys())
|
||||
for(Method m : patches.get(p))
|
||||
success = success || processInjector(classNode, p, m);
|
||||
success = processInjector(classNode, p, m) || success;
|
||||
LOGGER.info("Altered class {}", classNode.name);
|
||||
return success ? ComputeFlags.COMPUTE_FRAMES : ComputeFlags.NO_REWRITE; //todo: is this the right flag?
|
||||
}
|
||||
} else return ComputeFlags.NO_REWRITE;
|
||||
}
|
||||
|
||||
private boolean hasAnnotation(String name) throws IOException {
|
||||
/* TODO: Get fucking rid of this!
|
||||
* This method is pure evil. It scans the JAR and forcefully loads the patches.
|
||||
* Sure, it works, but it makes it impossible to split Patch Framework and client. It's
|
||||
* also very slow.
|
||||
* Cherry on top: ClassPath in Guava 21 is broken. My solution was to shamelessly paste
|
||||
* the version from Guava 22 as ClassPath22. License-wise there shouldn't be any problem,
|
||||
* but I have no intention of keeping it. It's only used here, and this method needs to
|
||||
* go as soon as humanly possible. Don't worry, I'm not bloating your precious codebase.
|
||||
* P.S.: Yes, that's why your shot at dynloading Modules didn't work.
|
||||
**/
|
||||
private static void loadPatchesPozzed() {
|
||||
try {
|
||||
ClassPath22.from(BoSCoVicinoLoader.class.getClassLoader())
|
||||
.getAllClasses()
|
||||
.stream()
|
||||
.filter(ci -> {
|
||||
try {
|
||||
return hasAnnotation(ci.getName());
|
||||
} catch(IOException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
})
|
||||
.map(ClassPath22.ClassInfo::load)
|
||||
.forEach(patch -> {
|
||||
patchClasses.put(patch.getAnnotation(Patch.class).value(), patch);
|
||||
LOGGER.info("Found patch class {}", patch.getName());
|
||||
});
|
||||
} catch(IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean hasAnnotation(String name) throws IOException {
|
||||
ClassReader cr = new ClassReader(name);
|
||||
AnnotationChecker ac = new AnnotationChecker(Patch.class);
|
||||
cr.accept(ac, 0);
|
||||
return ac.isAnnotationPresent();
|
||||
}
|
||||
|
||||
private Set<Method> getInjectorsInPatch(Class<?> patch) {
|
||||
private static Set<Method> getInjectorsInPatch(Class<?> patch) {
|
||||
return Arrays.stream(patch.getDeclaredMethods())
|
||||
.filter(m -> m.isAnnotationPresent(Inject.class))
|
||||
.collect(Collectors.toSet());
|
||||
}
|
||||
|
||||
public static String descriptorBuilder(Class<?> returnType, Class<?>[] parameters) {
|
||||
public static String descriptorBuilder(@Nullable Class<?> returnType, Class<?> ... parameters) {
|
||||
StringBuilder desc = new StringBuilder("(");
|
||||
for(Class<?> p : parameters)
|
||||
desc.append(Type.getDescriptor(p));
|
||||
desc.append(")");
|
||||
desc.append(Type.getDescriptor(returnType));
|
||||
if(returnType != null)
|
||||
desc.append(Type.getDescriptor(returnType));
|
||||
return desc.toString();
|
||||
}
|
||||
|
||||
private boolean processInjector(ClassNode target, Object patch, Method injector) {
|
||||
public static String descriptorBuilder(Class<?>[] parameters) {
|
||||
return descriptorBuilder(null, parameters);
|
||||
}
|
||||
|
||||
private static String deobfuscator(String srg) {
|
||||
/* FIXME: this will only work in client env (runClient task)
|
||||
Find a different way to deobf searge names or try to circumvent
|
||||
this step altogether (serve already deobfed names?) */
|
||||
return ObfuscationReflectionHelper.remapName(INameMappingService.Domain.METHOD, srg);
|
||||
}
|
||||
|
||||
private static boolean processInjector(ClassNode target, Object patch, Method injector) {
|
||||
//get relevant method from target
|
||||
Optional<MethodNode> targetMethod =
|
||||
target.methods
|
||||
.stream()
|
||||
.filter(m -> {
|
||||
Inject a = injector.getAnnotation(Inject.class);
|
||||
return m.name.equals(a.methodName()) && m.desc.equals(descriptorBuilder(a.returnType(), a.parameters()));
|
||||
return m.name.equals(a.methodName()) && m.desc.startsWith(descriptorBuilder(a.parameters()));
|
||||
})
|
||||
.findAny(); //there can literally only be one so this is safe and more efficient than findFirst
|
||||
|
||||
|
|
|
@ -8,5 +8,5 @@ import java.lang.annotation.Target;
|
|||
@Target(ElementType.TYPE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface Patch {
|
||||
Class<?> value();
|
||||
String value();
|
||||
}
|
||||
|
|
30
src/main/java/bscv/asm/patches/TestPatch.java
Normal file
30
src/main/java/bscv/asm/patches/TestPatch.java
Normal file
|
@ -0,0 +1,30 @@
|
|||
package bscv.asm.patches;
|
||||
|
||||
import bscv.asm.api.annotations.Inject;
|
||||
import bscv.asm.api.annotations.Patch;
|
||||
import org.objectweb.asm.Opcodes;
|
||||
import org.objectweb.asm.tree.InsnList;
|
||||
import org.objectweb.asm.tree.InsnNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
|
||||
/**
|
||||
* When working as intended, this patch will crash the game
|
||||
* as soon it finished loading with a NegativeArraySizeException.
|
||||
*/
|
||||
@Patch("net.minecraft.client.Minecraft")
|
||||
public class TestPatch implements Opcodes {
|
||||
|
||||
@Inject(methodName = "tick", returnType = void.class, parameters = {}, description = "Test injection!")
|
||||
public void inject(MethodNode main) {
|
||||
InsnList insnList = new InsnList();
|
||||
insnList.add(new InsnNode(POP));
|
||||
insnList.add(new InsnNode(POP));
|
||||
insnList.add(new InsnNode(POP));
|
||||
insnList.add(new InsnNode(POP));
|
||||
insnList.add(new InsnNode(POP));
|
||||
insnList.add(new InsnNode(POP));
|
||||
insnList.add(new InsnNode(POP));
|
||||
insnList.add(new InsnNode(POP));
|
||||
main.instructions.insert(insnList);
|
||||
}
|
||||
}
|
670
src/main/java/bscv/asm/util/ClassPath22.java
Normal file
670
src/main/java/bscv/asm/util/ClassPath22.java
Normal file
|
@ -0,0 +1,670 @@
|
|||
package bscv.asm.util;
|
||||
|
||||
import static com.google.common.base.Preconditions.checkArgument;
|
||||
import static com.google.common.base.Preconditions.checkNotNull;
|
||||
import static com.google.common.base.StandardSystemProperty.JAVA_CLASS_PATH;
|
||||
import static com.google.common.base.StandardSystemProperty.PATH_SEPARATOR;
|
||||
import static java.util.logging.Level.WARNING;
|
||||
|
||||
import com.google.common.annotations.VisibleForTesting;
|
||||
import com.google.common.base.CharMatcher;
|
||||
import com.google.common.base.Splitter;
|
||||
import com.google.common.collect.FluentIterable;
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.ImmutableMap;
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.google.common.collect.Maps;
|
||||
import com.google.common.io.ByteSource;
|
||||
import com.google.common.io.CharSource;
|
||||
import com.google.common.io.Resources;
|
||||
import com.google.common.reflect.Reflection;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URISyntaxException;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
import java.nio.charset.Charset;
|
||||
import java.util.Enumeration;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.Map;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.Set;
|
||||
import java.util.jar.Attributes;
|
||||
import java.util.jar.JarEntry;
|
||||
import java.util.jar.JarFile;
|
||||
import java.util.jar.Manifest;
|
||||
import java.util.logging.Logger;
|
||||
import javax.annotation.CheckForNull;
|
||||
|
||||
/**
|
||||
* Scans the source of a {@link ClassLoader} and finds all loadable classes and resources.
|
||||
*
|
||||
* <h2>Prefer <a href="https://github.com/classgraph/classgraph/wiki">ClassGraph</a> over {@code
|
||||
* ClassPath22}</h2>
|
||||
*
|
||||
* <p>We recommend using <a href="https://github.com/classgraph/classgraph/wiki">ClassGraph</a>
|
||||
* instead of {@code ClassPath22}. ClassGraph improves upon {@code ClassPath22} in several ways,
|
||||
* including addressing many of its limitations. Limitations of {@code ClassPath22} include:
|
||||
*
|
||||
* <ul>
|
||||
* <li>It looks only for files and JARs in URLs available from {@link URLClassLoader} instances or
|
||||
* the {@linkplain ClassLoader#getSystemClassLoader() system class loader}. This means it does
|
||||
* not look for classes in the <i>module path</i>.
|
||||
* <li>It understands only {@code file:} URLs. This means that it does not understand <a
|
||||
* href="https://openjdk.java.net/jeps/220">{@code jrt:/} URLs</a>, among <a
|
||||
* href="https://github.com/classgraph/classgraph/wiki/Classpath-specification-mechanisms">others</a>.
|
||||
* <li>It does not know how to look for classes when running under an Android VM. (ClassGraph does
|
||||
* not support this directly, either, but ClassGraph documents how to <a
|
||||
* href="https://github.com/classgraph/classgraph/wiki/Build-Time-Scanning">perform build-time
|
||||
* classpath scanning and make the results available to an Android app</a>.)
|
||||
* <li>Like all of Guava, it is not tested under Windows. We have gotten <a
|
||||
* href="https://github.com/google/guava/issues/2130">a report of a specific bug under
|
||||
* Windows</a>.
|
||||
* <li>It <a href="https://github.com/google/guava/issues/2712">returns only one resource for a
|
||||
* given path</a>, even if resources with that path appear in multiple jars or directories.
|
||||
* <li>It assumes that <a href="https://github.com/google/guava/issues/3349">any class with a
|
||||
* {@code $} in its name is a nested class</a>.
|
||||
* </ul>
|
||||
*
|
||||
* <h2>{@code ClassPath22} and symlinks</h2>
|
||||
*
|
||||
* <p>In the case of directory classloaders, symlinks are supported but cycles are not traversed.
|
||||
* This guarantees discovery of each <em>unique</em> loadable resource. However, not all possible
|
||||
* aliases for resources on cyclic paths will be listed.
|
||||
*
|
||||
* @author Ben Yu
|
||||
* @since 14.0
|
||||
*/
|
||||
public final class ClassPath22 {
|
||||
private static final Logger logger = Logger.getLogger(ClassPath22.class.getName());
|
||||
|
||||
/** Separator for the Class-Path manifest attribute value in jar files. */
|
||||
private static final Splitter CLASS_PATH_ATTRIBUTE_SEPARATOR =
|
||||
Splitter.on(" ").omitEmptyStrings();
|
||||
|
||||
private static final String CLASS_FILE_NAME_EXTENSION = ".class";
|
||||
|
||||
private final ImmutableSet<ResourceInfo> resources;
|
||||
|
||||
private ClassPath22(ImmutableSet<ResourceInfo> resources) {
|
||||
this.resources = resources;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a {@code ClassPath22} representing all classes and resources loadable from {@code
|
||||
* classloader} and its ancestor class loaders.
|
||||
*
|
||||
* <p><b>Warning:</b> {@code ClassPath22} can find classes and resources only from:
|
||||
*
|
||||
* <ul>
|
||||
* <li>{@link URLClassLoader} instances' {@code file:} URLs
|
||||
* <li>the {@linkplain ClassLoader#getSystemClassLoader() system class loader}. To search the
|
||||
* system class loader even when it is not a {@link URLClassLoader} (as in Java 9), {@code
|
||||
* ClassPath22} searches the files from the {@code java.class.path} system property.
|
||||
* </ul>
|
||||
*
|
||||
* @throws IOException if the attempt to read class path resources (jar files or directories)
|
||||
* failed.
|
||||
*/
|
||||
public static ClassPath22 from(ClassLoader classloader) throws IOException {
|
||||
ImmutableSet<LocationInfo> locations = locationsFrom(classloader);
|
||||
|
||||
// Add all locations to the scanned set so that in a classpath [jar1, jar2], where jar1 has a
|
||||
// manifest with Class-Path pointing to jar2, we won't scan jar2 twice.
|
||||
Set<File> scanned = new HashSet<>();
|
||||
for (LocationInfo location : locations) {
|
||||
scanned.add(location.file());
|
||||
}
|
||||
|
||||
// Scan all locations
|
||||
ImmutableSet.Builder<ResourceInfo> builder = ImmutableSet.builder();
|
||||
for (LocationInfo location : locations) {
|
||||
builder.addAll(location.scanResources(scanned));
|
||||
}
|
||||
return new ClassPath22(builder.build());
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all resources loadable from the current class path, including the class files of all
|
||||
* loadable classes but excluding the "META-INF/MANIFEST.MF" file.
|
||||
*/
|
||||
public ImmutableSet<ResourceInfo> getResources() {
|
||||
return resources;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all classes loadable from the current class path.
|
||||
*
|
||||
* @since 16.0
|
||||
*/
|
||||
public ImmutableSet<ClassInfo> getAllClasses() {
|
||||
return FluentIterable.from(resources).filter(ClassInfo.class).toSet();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all top level classes loadable from the current class path. Note that "top-level-ness"
|
||||
* is determined heuristically by class name (see {@link ClassInfo#isTopLevel}).
|
||||
*/
|
||||
public ImmutableSet<ClassInfo> getTopLevelClasses() {
|
||||
return FluentIterable.from(resources)
|
||||
.filter(ClassInfo.class)
|
||||
.filter(ClassInfo::isTopLevel)
|
||||
.toSet();
|
||||
}
|
||||
|
||||
/** Returns all top level classes whose package name is {@code packageName}. */
|
||||
public ImmutableSet<ClassInfo> getTopLevelClasses(String packageName) {
|
||||
checkNotNull(packageName);
|
||||
ImmutableSet.Builder<ClassInfo> builder = ImmutableSet.builder();
|
||||
for (ClassInfo classInfo : getTopLevelClasses()) {
|
||||
if (classInfo.getPackageName().equals(packageName)) {
|
||||
builder.add(classInfo);
|
||||
}
|
||||
}
|
||||
return builder.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all top level classes whose package name is {@code packageName} or starts with {@code
|
||||
* packageName} followed by a '.'.
|
||||
*/
|
||||
public ImmutableSet<ClassInfo> getTopLevelClassesRecursive(String packageName) {
|
||||
checkNotNull(packageName);
|
||||
String packagePrefix = packageName + '.';
|
||||
ImmutableSet.Builder<ClassInfo> builder = ImmutableSet.builder();
|
||||
for (ClassInfo classInfo : getTopLevelClasses()) {
|
||||
if (classInfo.getName().startsWith(packagePrefix)) {
|
||||
builder.add(classInfo);
|
||||
}
|
||||
}
|
||||
return builder.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a class path resource that can be either a class file or any other resource file
|
||||
* loadable from the class path.
|
||||
*
|
||||
* @since 14.0
|
||||
*/
|
||||
public static class ResourceInfo {
|
||||
private final File file;
|
||||
private final String resourceName;
|
||||
|
||||
final ClassLoader loader;
|
||||
|
||||
static ResourceInfo of(File file, String resourceName, ClassLoader loader) {
|
||||
if (resourceName.endsWith(CLASS_FILE_NAME_EXTENSION)) {
|
||||
return new ClassInfo(file, resourceName, loader);
|
||||
} else {
|
||||
return new ResourceInfo(file, resourceName, loader);
|
||||
}
|
||||
}
|
||||
|
||||
ResourceInfo(File file, String resourceName, ClassLoader loader) {
|
||||
this.file = checkNotNull(file);
|
||||
this.resourceName = checkNotNull(resourceName);
|
||||
this.loader = checkNotNull(loader);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the url identifying the resource.
|
||||
*
|
||||
* <p>See {@link ClassLoader#getResource}
|
||||
*
|
||||
* @throws NoSuchElementException if the resource cannot be loaded through the class loader,
|
||||
* despite physically existing in the class path.
|
||||
*/
|
||||
public final URL url() {
|
||||
URL url = loader.getResource(resourceName);
|
||||
if (url == null) {
|
||||
throw new NoSuchElementException(resourceName);
|
||||
}
|
||||
return url;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a {@link ByteSource} view of the resource from which its bytes can be read.
|
||||
*
|
||||
* @throws NoSuchElementException if the resource cannot be loaded through the class loader,
|
||||
* despite physically existing in the class path.
|
||||
* @since 20.0
|
||||
*/
|
||||
public final ByteSource asByteSource() {
|
||||
return Resources.asByteSource(url());
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a {@link CharSource} view of the resource from which its bytes can be read as
|
||||
* characters decoded with the given {@code charset}.
|
||||
*
|
||||
* @throws NoSuchElementException if the resource cannot be loaded through the class loader,
|
||||
* despite physically existing in the class path.
|
||||
* @since 20.0
|
||||
*/
|
||||
public final CharSource asCharSource(Charset charset) {
|
||||
return Resources.asCharSource(url(), charset);
|
||||
}
|
||||
|
||||
/** Returns the fully qualified name of the resource. Such as "com/mycomp/foo/bar.txt". */
|
||||
public final String getResourceName() {
|
||||
return resourceName;
|
||||
}
|
||||
|
||||
/** Returns the file that includes this resource. */
|
||||
final File getFile() {
|
||||
return file;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return resourceName.hashCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(@CheckForNull Object obj) {
|
||||
if (obj instanceof ResourceInfo) {
|
||||
ResourceInfo that = (ResourceInfo) obj;
|
||||
return resourceName.equals(that.resourceName) && loader == that.loader;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Do not change this arbitrarily. We rely on it for sorting ResourceInfo.
|
||||
@Override
|
||||
public String toString() {
|
||||
return resourceName;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a class that can be loaded through {@link #load}.
|
||||
*
|
||||
* @since 14.0
|
||||
*/
|
||||
public static final class ClassInfo extends ResourceInfo {
|
||||
private final String className;
|
||||
|
||||
ClassInfo(File file, String resourceName, ClassLoader loader) {
|
||||
super(file, resourceName, loader);
|
||||
this.className = getClassName(resourceName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the package name of the class, without attempting to load the class.
|
||||
*
|
||||
* <p>Behaves similarly to {@code class.getPackage().}{@link Package#getName() getName()} but
|
||||
* does not require the class (or package) to be loaded.
|
||||
*
|
||||
* <p>But note that this method may behave differently for a class in the default package: For
|
||||
* such classes, this method always returns an empty string. But under some version of Java,
|
||||
* {@code class.getPackage().getName()} produces a {@code NullPointerException} because {@code
|
||||
* class.getPackage()} returns {@code null}.
|
||||
*/
|
||||
public String getPackageName() {
|
||||
return Reflection.getPackageName(className);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the simple name of the underlying class as given in the source code.
|
||||
*
|
||||
* <p>Behaves similarly to {@link Class#getSimpleName()} but does not require the class to be
|
||||
* loaded.
|
||||
*
|
||||
* <p>But note that this class uses heuristics to identify the simple name. See a related
|
||||
* discussion in <a href="https://github.com/google/guava/issues/3349">issue 3349</a>.
|
||||
*/
|
||||
public String getSimpleName() {
|
||||
int lastDollarSign = className.lastIndexOf('$');
|
||||
if (lastDollarSign != -1) {
|
||||
String innerClassName = className.substring(lastDollarSign + 1);
|
||||
// local and anonymous classes are prefixed with number (1,2,3...), anonymous classes are
|
||||
// entirely numeric whereas local classes have the user supplied name as a suffix
|
||||
return CharMatcher.inRange('0', '9').trimLeadingFrom(innerClassName);
|
||||
}
|
||||
String packageName = getPackageName();
|
||||
if (packageName.isEmpty()) {
|
||||
return className;
|
||||
}
|
||||
|
||||
// Since this is a top level class, its simple name is always the part after package name.
|
||||
return className.substring(packageName.length() + 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the fully qualified name of the class.
|
||||
*
|
||||
* <p>Behaves identically to {@link Class#getName()} but does not require the class to be
|
||||
* loaded.
|
||||
*/
|
||||
public String getName() {
|
||||
return className;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the class name "looks to be" top level (not nested), that is, it includes no
|
||||
* '$' in the name. This method may return false for a top-level class that's intentionally
|
||||
* named with the '$' character. If this is a concern, you could use {@link #load} and then
|
||||
* check on the loaded {@link Class} object instead.
|
||||
*
|
||||
* @since 30.1
|
||||
*/
|
||||
public boolean isTopLevel() {
|
||||
return className.indexOf('$') == -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads (but doesn't link or initialize) the class.
|
||||
*
|
||||
* @throws LinkageError when there were errors in loading classes that this class depends on.
|
||||
* For example, {@link NoClassDefFoundError}.
|
||||
*/
|
||||
public Class<?> load() {
|
||||
try {
|
||||
return loader.loadClass(className);
|
||||
} catch (ClassNotFoundException e) {
|
||||
// Shouldn't happen, since the class name is read from the class path.
|
||||
throw new IllegalStateException(e);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return className;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all locations that {@code classloader} and parent loaders load classes and resources
|
||||
* from. Callers can {@linkplain LocationInfo#scanResources scan} individual locations selectively
|
||||
* or even in parallel.
|
||||
*/
|
||||
static ImmutableSet<LocationInfo> locationsFrom(ClassLoader classloader) {
|
||||
ImmutableSet.Builder<LocationInfo> builder = ImmutableSet.builder();
|
||||
for (Map.Entry<File, ClassLoader> entry : getClassPathEntries(classloader).entrySet()) {
|
||||
builder.add(new LocationInfo(entry.getKey(), entry.getValue()));
|
||||
}
|
||||
return builder.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a single location (a directory or a jar file) in the class path and is responsible
|
||||
* for scanning resources from this location.
|
||||
*/
|
||||
static final class LocationInfo {
|
||||
final File home;
|
||||
private final ClassLoader classloader;
|
||||
|
||||
LocationInfo(File home, ClassLoader classloader) {
|
||||
this.home = checkNotNull(home);
|
||||
this.classloader = checkNotNull(classloader);
|
||||
}
|
||||
|
||||
/** Returns the file this location is from. */
|
||||
public final File file() {
|
||||
return home;
|
||||
}
|
||||
|
||||
/** Scans this location and returns all scanned resources. */
|
||||
public ImmutableSet<ResourceInfo> scanResources() throws IOException {
|
||||
return scanResources(new HashSet<File>());
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans this location and returns all scanned resources.
|
||||
*
|
||||
* <p>This file and jar files from "Class-Path" entry in the scanned manifest files will be
|
||||
* added to {@code scannedFiles}.
|
||||
*
|
||||
* <p>A file will be scanned at most once even if specified multiple times by one or multiple
|
||||
* jar files' "Class-Path" manifest entries. Particularly, if a jar file from the "Class-Path"
|
||||
* manifest entry is already in {@code scannedFiles}, either because it was scanned earlier, or
|
||||
* it was intentionally added to the set by the caller, it will not be scanned again.
|
||||
*
|
||||
* <p>Note that when you call {@code location.scanResources(scannedFiles)}, the location will
|
||||
* always be scanned even if {@code scannedFiles} already contains it.
|
||||
*/
|
||||
public ImmutableSet<ResourceInfo> scanResources(Set<File> scannedFiles) throws IOException {
|
||||
ImmutableSet.Builder<ResourceInfo> builder = ImmutableSet.builder();
|
||||
scannedFiles.add(home);
|
||||
scan(home, scannedFiles, builder);
|
||||
return builder.build();
|
||||
}
|
||||
|
||||
private void scan(File file, Set<File> scannedUris, ImmutableSet.Builder<ResourceInfo> builder)
|
||||
throws IOException {
|
||||
try {
|
||||
if (!file.exists()) {
|
||||
return;
|
||||
}
|
||||
} catch (SecurityException e) {
|
||||
logger.warning("Cannot access " + file + ": " + e);
|
||||
// TODO(emcmanus): consider whether to log other failure cases too.
|
||||
return;
|
||||
}
|
||||
if (file.isDirectory()) {
|
||||
scanDirectory(file, builder);
|
||||
} else {
|
||||
scanJar(file, scannedUris, builder);
|
||||
}
|
||||
}
|
||||
|
||||
private void scanJar(
|
||||
File file, Set<File> scannedUris, ImmutableSet.Builder<ResourceInfo> builder)
|
||||
throws IOException {
|
||||
JarFile jarFile;
|
||||
try {
|
||||
jarFile = new JarFile(file);
|
||||
} catch (IOException e) {
|
||||
// Not a jar file
|
||||
return;
|
||||
}
|
||||
try {
|
||||
for (File path : getClassPathFromManifest(file, jarFile.getManifest())) {
|
||||
// We only scan each file once independent of the classloader that file might be
|
||||
// associated with.
|
||||
if (scannedUris.add(path.getCanonicalFile())) {
|
||||
scan(path, scannedUris, builder);
|
||||
}
|
||||
}
|
||||
scanJarFile(jarFile, builder);
|
||||
} finally {
|
||||
try {
|
||||
jarFile.close();
|
||||
} catch (IOException ignored) { // similar to try-with-resources, but don't fail scanning
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void scanJarFile(JarFile file, ImmutableSet.Builder<ResourceInfo> builder) {
|
||||
Enumeration<JarEntry> entries = file.entries();
|
||||
while (entries.hasMoreElements()) {
|
||||
JarEntry entry = entries.nextElement();
|
||||
if (entry.isDirectory() || entry.getName().equals(JarFile.MANIFEST_NAME)) {
|
||||
continue;
|
||||
}
|
||||
builder.add(ResourceInfo.of(new File(file.getName()), entry.getName(), classloader));
|
||||
}
|
||||
}
|
||||
|
||||
private void scanDirectory(File directory, ImmutableSet.Builder<ResourceInfo> builder)
|
||||
throws IOException {
|
||||
Set<File> currentPath = new HashSet<>();
|
||||
currentPath.add(directory.getCanonicalFile());
|
||||
scanDirectory(directory, "", currentPath, builder);
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursively scan the given directory, adding resources for each file encountered. Symlinks
|
||||
* which have already been traversed in the current tree path will be skipped to eliminate
|
||||
* cycles; otherwise symlinks are traversed.
|
||||
*
|
||||
* @param directory the root of the directory to scan
|
||||
* @param packagePrefix resource path prefix inside {@code classloader} for any files found
|
||||
* under {@code directory}
|
||||
* @param currentPath canonical files already visited in the current directory tree path, for
|
||||
* cycle elimination
|
||||
*/
|
||||
private void scanDirectory(
|
||||
File directory,
|
||||
String packagePrefix,
|
||||
Set<File> currentPath,
|
||||
ImmutableSet.Builder<ResourceInfo> builder)
|
||||
throws IOException {
|
||||
File[] files = directory.listFiles();
|
||||
if (files == null) {
|
||||
logger.warning("Cannot read directory " + directory);
|
||||
// IO error, just skip the directory
|
||||
return;
|
||||
}
|
||||
for (File f : files) {
|
||||
String name = f.getName();
|
||||
if (f.isDirectory()) {
|
||||
File deref = f.getCanonicalFile();
|
||||
if (currentPath.add(deref)) {
|
||||
scanDirectory(deref, packagePrefix + name + "/", currentPath, builder);
|
||||
currentPath.remove(deref);
|
||||
}
|
||||
} else {
|
||||
String resourceName = packagePrefix + name;
|
||||
if (!resourceName.equals(JarFile.MANIFEST_NAME)) {
|
||||
builder.add(ResourceInfo.of(f, resourceName, classloader));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(@CheckForNull Object obj) {
|
||||
if (obj instanceof LocationInfo) {
|
||||
LocationInfo that = (LocationInfo) obj;
|
||||
return home.equals(that.home) && classloader.equals(that.classloader);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return home.hashCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return home.toString();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the class path URIs specified by the {@code Class-Path} manifest attribute, according
|
||||
* to <a
|
||||
* href="http://docs.oracle.com/javase/8/docs/technotes/guides/jar/jar.html#Main_Attributes">JAR
|
||||
* File Specification</a>. If {@code manifest} is null, it means the jar file has no manifest, and
|
||||
* an empty set will be returned.
|
||||
*/
|
||||
@VisibleForTesting
|
||||
static ImmutableSet<File> getClassPathFromManifest(
|
||||
File jarFile, @CheckForNull Manifest manifest) {
|
||||
if (manifest == null) {
|
||||
return ImmutableSet.of();
|
||||
}
|
||||
ImmutableSet.Builder<File> builder = ImmutableSet.builder();
|
||||
String classpathAttribute =
|
||||
manifest.getMainAttributes().getValue(Attributes.Name.CLASS_PATH.toString());
|
||||
if (classpathAttribute != null) {
|
||||
for (String path : CLASS_PATH_ATTRIBUTE_SEPARATOR.split(classpathAttribute)) {
|
||||
URL url;
|
||||
try {
|
||||
url = getClassPathEntry(jarFile, path);
|
||||
} catch (MalformedURLException e) {
|
||||
// Ignore bad entry
|
||||
logger.warning("Invalid Class-Path entry: " + path);
|
||||
continue;
|
||||
}
|
||||
if (url.getProtocol().equals("file")) {
|
||||
builder.add(toFile(url));
|
||||
}
|
||||
}
|
||||
}
|
||||
return builder.build();
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
static ImmutableMap<File, ClassLoader> getClassPathEntries(ClassLoader classloader) {
|
||||
LinkedHashMap<File, ClassLoader> entries = Maps.newLinkedHashMap();
|
||||
// Search parent first, since it's the order ClassLoader#loadClass() uses.
|
||||
ClassLoader parent = classloader.getParent();
|
||||
if (parent != null) {
|
||||
entries.putAll(getClassPathEntries(parent));
|
||||
}
|
||||
for (URL url : getClassLoaderUrls(classloader)) {
|
||||
if (url.getProtocol().equals("file")) {
|
||||
File file = toFile(url);
|
||||
if (!entries.containsKey(file)) {
|
||||
entries.put(file, classloader);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ImmutableMap.copyOf(entries);
|
||||
}
|
||||
|
||||
private static ImmutableList<URL> getClassLoaderUrls(ClassLoader classloader) {
|
||||
if (classloader instanceof URLClassLoader) {
|
||||
return ImmutableList.copyOf(((URLClassLoader) classloader).getURLs());
|
||||
}
|
||||
if (classloader.equals(ClassLoader.getSystemClassLoader())) {
|
||||
return parseJavaClassPath();
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the URLs in the class path specified by the {@code java.class.path} {@linkplain
|
||||
* System#getProperty system property}.
|
||||
*/
|
||||
@VisibleForTesting // TODO(b/65488446): Make this a public API.
|
||||
static ImmutableList<URL> parseJavaClassPath() {
|
||||
ImmutableList.Builder<URL> urls = ImmutableList.builder();
|
||||
for (String entry : Splitter.on(PATH_SEPARATOR.value()).split(JAVA_CLASS_PATH.value())) {
|
||||
try {
|
||||
try {
|
||||
urls.add(new File(entry).toURI().toURL());
|
||||
} catch (SecurityException e) { // File.toURI checks to see if the file is a directory
|
||||
urls.add(new URL("file", null, new File(entry).getAbsolutePath()));
|
||||
}
|
||||
} catch (MalformedURLException e) {
|
||||
logger.log(WARNING, "malformed classpath entry: " + entry, e);
|
||||
}
|
||||
}
|
||||
return urls.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the absolute uri of the Class-Path entry value as specified in <a
|
||||
* href="http://docs.oracle.com/javase/8/docs/technotes/guides/jar/jar.html#Main_Attributes">JAR
|
||||
* File Specification</a>. Even though the specification only talks about relative urls, absolute
|
||||
* urls are actually supported too (for example, in Maven surefire plugin).
|
||||
*/
|
||||
@VisibleForTesting
|
||||
static URL getClassPathEntry(File jarFile, String path) throws MalformedURLException {
|
||||
return new URL(jarFile.toURI().toURL(), path);
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
static String getClassName(String filename) {
|
||||
int classNameEnd = filename.length() - CLASS_FILE_NAME_EXTENSION.length();
|
||||
return filename.substring(0, classNameEnd).replace('/', '.');
|
||||
}
|
||||
|
||||
// TODO(benyu): Try java.nio.file.Paths#get() when Guava drops JDK 6 support.
|
||||
@VisibleForTesting
|
||||
static File toFile(URL url) {
|
||||
checkArgument(url.getProtocol().equals("file"));
|
||||
try {
|
||||
return new File(url.toURI()); // Accepts escaped characters like %20.
|
||||
} catch (URISyntaxException e) { // URL.toURI() doesn't escape chars.
|
||||
return new File(url.getPath()); // Accepts non-escaped chars like space.
|
||||
}
|
||||
}
|
||||
}
|
Loading…
Reference in a new issue