public static void accept(URLClassLoader ucl, Visitor visitor) throws IOException { accept(ucl, ucl.getURLs(), visitor); }
@Override public void visit(String resource, URL url, ClassLoader cl) { if (!isClassFile(resource)) return; final String className = ClassLoaderUtil.resourceToClass(resource); // System.out.println("className: " + className + " " // + ASMUtil.isAssignableFrom(Actor.class, className, ActorModule.this) + " " // + " " + url + " " + ActorModule.this.parent.getResource(resource) + " " // + equalContent(ActorModule.this.parent.getResource(resource), url)); if (isAutomaticUpgrade(className) && !equalContent(ActorModule.this.parent.getResource(resource), url)) builder.add(className); } });
public static String classToResource(Class<?> clazz) { if (clazz == null) return null; return classToResource(clazz.getName()); }
@Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { try { if (isClassFile(file.getFileName().toString())) classFileVisitor.apply(Files.newInputStream(file)); return FileVisitResult.CONTINUE; } catch (Exception e) { throw new RuntimeException("Exception while processing " + file, e); } } });
private ClassNode fill(ClassNode node) { if (node.supers == null) { try (InputStream is = ClassLoaderUtil.getResourceAsStream(cl, classToResource(node.name))) { final ClassReader cr = new ClassReader(is); cr.accept(new ClassNodeVisitor(false, ASMAPI, null), ClassReader.SKIP_DEBUG | ClassReader.SKIP_CODE); assert node.supers != null; } catch (IOException e) { throw new RuntimeException("during processing of " + node.name, e); } } return node; }
private static void scanJar(File file, ClassLoader classloader, Set<URI> scannedUris, Visitor visitor) throws IOException { JarFile jarFile; try { jarFile = new JarFile(file); } catch (IOException e) { // Not a jar file return; } try { for (URI uri : getClassPathFromManifest(file, jarFile.getManifest())) scan(uri, classloader, scannedUris, visitor); for (Enumeration<JarEntry> entries = jarFile.entries(); entries.hasMoreElements();) { JarEntry entry = entries.nextElement(); if (entry.isDirectory() || entry.getName().equals(JarFile.MANIFEST_NAME)) continue; try { visitor.visit(entry.getName(), new URL("jar:file:" + file.getCanonicalPath() + "!/" + entry.getName()), classloader); } catch (IOException e) { throw new IOException("Exception thrown during scanning of jar file " + file + " entry " + entry, e); } catch (RuntimeException e) { throw new RuntimeException("Exception thrown during scanning of jar file " + file + " entry " + entry, e); } } } finally { try { jarFile.close(); } catch (IOException ignored) { } } }
public static String classToSlashed(Class<?> clazz) { if (clazz == null) return null; return classToSlashed(clazz.getName()); }
private String extractSuperClass(String className) { ClassLoader cl = null; if (clRef != null) { cl = clRef.get(); if (cl == null) { return null; } } try (final InputStream is = ClassLoaderUtil.getResourceAsStream(cl, className + ".class")) { ClassReader r = new ClassReader(is); ExtractSuperClass esc = new ExtractSuperClass(); r.accept(esc, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); return esc.superClass; } catch (IOException ex) { error(className, ex); } return null; }
public static InputStream getResourceAsStream(ClassLoader cl, String resource) throws IOException { URL url = getResource(cl, resource); if (url == null) return null; URLConnection uc = url.openConnection(); uc.setUseCaches(false); return uc.getInputStream(); }
/** * Returns the class path URIs specified by the {@code Class-Path} manifest attribute, according * to <a href="http://docs.oracle.com/javase/6/docs/technotes/guides/jar/jar.html#Main%20Attributes"> * JAR File Specification</a>. If {@code manifest} is null, it means the jar file has no * manifest, and an empty set will be returned. */ private static Set<URI> getClassPathFromManifest(File jarFile, Manifest manifest) { if (manifest == null) return new HashSet<>(); HashSet<URI> s = new HashSet<>(); String classpathAttribute = manifest.getMainAttributes().getValue(Attributes.Name.CLASS_PATH.toString()); if (classpathAttribute != null) { for (String path : classpathAttribute.split("\\s")) { if (path != null && path.trim().length() > 0) { URI uri; try { uri = getClassPathEntry(jarFile, path.trim()); } catch (URISyntaxException e) { // Ignore bad entry // logger.warning("Invalid Class-Path entry: " + path); continue; } s.add(uri); } } } return s; }
@Override public void visit(String resource, URL url, ClassLoader cl) throws IOException { if (resource.startsWith("java/util") || resource.startsWith("java/lang") || resource.startsWith("co/paralleluniverse/asm")) return; if (isClassFile(url.getFile())) { URLConnection uc = url.openConnection(); uc.setUseCaches(false); try (InputStream is = uc.getInputStream()) { if (is == null) throw new IOException("Resource " + resource + " not found (" + url + ")"); new ClassReader(is) .accept(new SuspendableClassifier(false, ASMAPI, null), ClassReader.SKIP_DEBUG | ClassReader.SKIP_CODE); } catch (Exception e) { throw new RuntimeException("Exception thrown during processing (aaa) of " + resource + /*"(classloader: " + Arrays.toString(SuspendablesScanner.this.cl.getURLs()) + ")" +*/ " at " + url, e); } } } });
public static boolean isAssignableFrom(Class<?> supertype, String className, ClassLoader cl) { return isAssignableFrom0(classToSlashed(supertype), classToSlashed(className), cl); }
try (final InputStream is = ClassLoaderUtil.getResourceAsStream(cl, className + ".class")) { if (is == null) { log(LogLevel.INFO, "Class not found: %s", className);
@Override public void visit(String resource, URL url, ClassLoader cl) { if (!isClassFile(resource)) return; final String className = ClassLoaderUtil.resourceToClass(resource); try (InputStream is = cl.getResourceAsStream(resource)) { if (AnnotationUtil.hasClassAnnotation(Upgrade.class, is)) { LOG.debug("Upgrade of class {} (annotated)", className); builder.add(className); } } catch (IOException e) { throw new RuntimeException("Exception while scanning class " + className + " for Upgrade annotation", e); } } });
private void scanExternalSuspendables() throws IOException { ClassLoaderUtil.accept(cl, new ClassLoaderUtil.Visitor() { @Override public void visit(String resource, URL url, ClassLoader cl) throws IOException { if (resource.startsWith("java/util") || resource.startsWith("java/lang") || resource.startsWith("co/paralleluniverse/asm")) return; if (isClassFile(url.getFile())) { URLConnection uc = url.openConnection(); uc.setUseCaches(false); try (InputStream is = uc.getInputStream()) { if (is == null) throw new IOException("Resource " + resource + " not found (" + url + ")"); new ClassReader(is) .accept(new SuspendableClassifier(false, ASMAPI, null), ClassReader.SKIP_DEBUG | ClassReader.SKIP_CODE); } catch (Exception e) { throw new RuntimeException("Exception thrown during processing (aaa) of " + resource + /*"(classloader: " + Arrays.toString(SuspendablesScanner.this.cl.getURLs()) + ")" +*/ " at " + url, e); } } } }); }
private void visitAntProject(Function<InputStream, Void> classFileVisitor) throws IOException { for (FileSet fs : filesets) { try { final DirectoryScanner ds = fs.getDirectoryScanner(getProject()); final String[] includedFiles = ds.getIncludedFiles(); for (String filename : includedFiles) { if (isClassFile(filename)) { try { File file = new File(fs.getDir(), filename); if (file.isFile()) classFileVisitor.apply(new FileInputStream(file)); else log("File not found: " + filename); } catch (Exception e) { throw new RuntimeException("Exception while processing " + filename, e); } } } } catch (BuildException ex) { log(ex.getMessage(), ex, Project.MSG_WARN); } } }
public static InputStream getClassInputStream(String className, ClassLoader cl) { final String resource = classToResource(className); return cl != null ? cl.getResourceAsStream(resource) : ClassLoader.getSystemResourceAsStream(resource); }
public static boolean isAssignableFrom(String supertypeName, String className, ClassLoader cl) { return isAssignableFrom0(classToSlashed(supertypeName), classToSlashed(className), cl); }
@Override public final void visit(String resource, URL url, ClassLoader cl) { if (!ClassLoaderUtil.isClassFile(resource)) return; final String className = ClassLoaderUtil.resourceToClass(resource); try (final InputStream is = cl.getResourceAsStream(resource)) { if (AnnotationUtil.hasClassAnnotation(WebActor.class, is)) registerWebActor(cl.loadClass(className)); } catch (final IOException | ClassNotFoundException e) { log.error("Exception while scanning class " + className + " for WebActor annotation", e); throw new RuntimeException(e); } }
private synchronized void registerActorClasses() { if (actorClasses.isEmpty()) { try { final ClassLoader classLoader = userClassLoader != null ? userClassLoader : this.getClass().getClassLoader(); ClassLoaderUtil.accept((URLClassLoader) classLoader, new ClassLoaderUtil.Visitor() { @Override public final void visit(String resource, URL url, ClassLoader cl) { if (!ClassLoaderUtil.isClassFile(resource)) return; final String className = ClassLoaderUtil.resourceToClass(resource); try (final InputStream is = cl.getResourceAsStream(resource)) { if (AnnotationUtil.hasClassAnnotation(WebActor.class, is)) registerWebActor(cl.loadClass(className)); } catch (final IOException | ClassNotFoundException e) { log.error("Exception while scanning class " + className + " for WebActor annotation", e); throw new RuntimeException(e); } } private void registerWebActor(Class<?> c) { actorClasses.add(c); } }); } catch (final IOException e) { log.error("IOException while scanning classes for WebActor annotation", e); } } } }