public void cleanListeners() { for(ClasspathResource resource : classpaths) { resource.removeSingleFireListeners(); } }
public void fireListeners() { for(ClasspathResource resource : classpaths) { resource.fireListeners(); } }
private void notifyAction(Set<ResourceScanListener> listeners, ResourceScanListener.ScanAction action) { for(ResourceScanListener listener : listeners) { listener.scanAction(action); } } }
public JawrConfig() { resourceScanListener = new JawrResourceScanListener(); ClasspathScanner.getInstance().registerResourceScanner(resourceScanListener); }
@Override public Properties getConfigProperties() { if (Flags.DEVMODE.on() || !scanned) { ClasspathScanner.getInstance().scan(getClass().getClassLoader(), true); } return jawrProperties; }
public List<ClasspathResource> scan(ClassLoader loader) { return scan(loader, true); }
public void triggerNotifications() { Set<ResourceScanListener> listeners = new HashSet<>(); for(ClasspathResource resource : classpaths) { resource.collectInUseListeners(listeners); } listeners.addAll(uncheckedListeners); notifyAction(listeners, ResourceScanListener.ScanAction.STARTING); askForInterest(); fireListeners(); cleanListeners(); notifyAction(listeners, ResourceScanListener.ScanAction.COMPLETE); }
@Override public boolean handlesClasspathResource(ClasspathResource resource, List<ResourceScanListener.ScanResource> scanResources) throws IOException { for(ClasspathResource.OffsetListener jarOffset : resource.getJarOffsets()) { String offset = jarOffset.jarOffset; // must be null, 0 or ending with .jar if (!(offset == null || offset.length() == 0 || offset.endsWith(".jar!/"))) { return false; } } // ok, looks like Spring loaded, or at least something Spring loaded can handle. JarFile jarFile = new JarFile(resource.getClassesSource()); for(ClasspathResource.OffsetListener jarOffset : resource.getJarOffsets()) { if (jarOffset.listeners != null && jarOffset.listeners.size() > 0) { String offset = jarOffset.jarOffset; JarFile processFile = jarFile; if (offset.endsWith(".jar!/")) { processFile = getNestedJarFile(jarFile, offset.substring(0, offset.length() - SEPARATOR.length())); } extractJarEntries(resource, jarOffset, scanResources, processFile); } } return true; }
public void extractJarEntries(ClasspathResource resource, ClasspathResource.OffsetListener offsetListener, List<ResourceScanListener.ScanResource> scanResources, java.util.jar.JarFile jf) { Enumeration<java.util.jar.JarEntry> entries = jf.entries(); while (entries.hasMoreElements()) { java.util.jar.JarEntry entry = entries.nextElement(); if (!entry.getName().endsWith(SEPARATOR)) { if (scanResources.size() >= ClasspathResource.MAX_RESOURCES) { resource.fireListeners(scanResources, offsetListener, jf); } } scanResources.add(new ResourceScanListener.ScanResource(offsetListener.interestingResource.url, entry, entry.getName(), offsetListener.interestingResource.url)); } // anything remaining resource.fireListeners(scanResources, offsetListener, jf); }
/** * Allows us to keep a track of who is interested in this classpath artifact * * @param listeners */ public void askListeners(List<ResourceScanListener> listeners) { if (jarOffsets.size() == 0) { OffsetListener offsetListener = new OffsetListener(); offsetListener.jarOffset = ""; offsetListener.interestingResource = new ResourceScanListener.InterestingResource(url); jarOffsets.add(offsetListener); onlyNullJarOffset = true; } for (ResourceScanListener listener : listeners) { try { for (OffsetListener offsetListener : jarOffsets) { ResourceScanListener.InterestAction interestAction = listener.isInteresting(offsetListener.interestingResource); if (interestAction != ResourceScanListener.InterestAction.NONE) { offsetListener.listeners.add(new ListenerInterest(listener, interestAction)); } } } catch (Exception ex) { throw new RuntimeException("Failed to ask listener for interest " + listener.getClass().getName() + ": " + ex.getMessage(), ex); } } }
private void processFile(List<ResourceScanListener.ScanResource> scanResources, String packageName, OffsetListener listener, File file) { scanResources.add(new ResourceScanListener.ScanResource(url, file, packageName + "/" + file.getName())); if (scanResources.size() >= MAX_RESOURCES) { fireFileResourceListeners(scanResources, listener); } }
/** * looks through all of the classpaths we have and finds the one that ends in target/test-classes - if it finds it, it returns its parent. * * @return - the base directory of the application currently running (if any) */ public static File findTestClassesBasePath() { for(Classpath cp : resources.values()) { for(ClasspathResource cr : cp.classpaths) { if (cr.isTestClasspath()) { return cr.getClassesSource().getParentFile().getParentFile(); } } } return null; } }
@Override public void deliver(ResourceScanListener.ScanResource desire, InputStream inputStream) { Properties properties = new Properties(); try { properties.load(inputStream); } catch (IOException e) { log.error("Failed to load {}", desire.getResolvedUrl().toString()); } config.putAll(properties); }
public static void resetScannerForTesting() { globalScanner = new ClasspathScanner(); releaseAllResources(); }
public void addJarOffset(String offset, URL url) { OffsetListener listener = new OffsetListener(); listener.jarOffset = offset.startsWith("/") ? offset.substring(1) : offset; listener.interestingResource = new ResourceScanListener.InterestingResource(url); jarOffsets.add(listener); }
private void processJarResource(String path, URL url, Map<String, ClasspathResource> fileMap, List<ClasspathResource> myResources) { path = path.substring(JAR_PREFIX.length() + FILE_PREFIX.length()); String offset = null; int offsetPos = path.indexOf('!'); if (offsetPos != -1) { offset = path.substring(offsetPos + 1); path = path.substring(0, offsetPos); } // does it already exist in the map? if so, stop processing and ignore ClasspathResource resource = fileMap.get(path); if (resource != null) { if (offset != null) { resource.addJarOffset(offset, url); } } else { foundJar(path, url, fileMap, offset, myResources); } }
protected void processDirectory(List<ResourceScanListener.ScanResource> scanResources, File dir, String packageName, OffsetListener listener) { File[] files = dir.listFiles(); if (files != null) { for (File file : files) { if (file.isDirectory()) { // as long as it isn't a "hidden" directory if (!file.getName().startsWith(".")) { processFile(scanResources, packageName, listener, file); // jars and dirs need to be added as resources String newPackageName = packageName; if (packageName.length() > 0) { newPackageName += "/"; } processDirectory(scanResources, file, newPackageName + file.getName(), listener); } } else { processFile(scanResources, packageName, listener, file); } } } }
public void askForInterest() { if (uncheckedListeners.size() > 0) { for(ClasspathResource resource : classpaths) { resource.askListeners(uncheckedListeners); } } // clearing them allows us to all this over and over and not worry uncheckedListeners.clear(); }
private void processFileResource(String path, URL url, Map<String, ClasspathResource> fileMap, List<ClasspathResource> myResources) { path = path.substring(FILE_PREFIX.length()); // does it already exist in the map? if so, stop processing and ignore ClasspathResource resource = fileMap.get(path); if (resource == null) { foundJar(path, url, fileMap, null, myResources); } }
/** * This allows specialist classpath handlers to exist for peculiar formats - e.g. Spring Loader. * * @param scanResources - the resources to be filled in * @return true if handled */ protected boolean externalHandler(List<ResourceScanListener.ScanResource> scanResources) { for(ClasspathScannerSpecialist specialist : ClasspathSpecialistLoader.specialists) { try { if (specialist.handlesClasspathResource(this, scanResources)) { return true; } } catch (IOException e) { log.error("Unable to process classpath resource {}", classesSource.getAbsolutePath(), e); } } return false; }