org.apache.tomcat.util.scan.StandardJarScanner Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.tomcat.util.scan;
import java.io.File;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLConnection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.StringTokenizer;
import javax.servlet.ServletContext;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.JarScanner;
import org.apache.tomcat.JarScannerCallback;
import org.apache.tomcat.util.file.Matcher;
import org.apache.tomcat.util.res.StringManager;
/**
* The default {@link JarScanner} implementation scans the WEB-INF/lib directory
* followed by the provided classloader and then works up the classloader
* hierarchy. This implementation is sufficient to meet the requirements of the
* Servlet 3.0 specification as well as to provide a number of Tomcat specific
* extensions. The extensions are:
*
* - Scanning the classloader hierarchy (enabled by default)
* - Testing all files to see if they are JARs (disabled by default)
* - Testing all directories to see if they are exploded JARs
* (disabled by default)
*
* All of the extensions may be controlled via configuration.
*/
public class StandardJarScanner implements JarScanner {
private static final Log log = LogFactory.getLog(StandardJarScanner.class);
private static final Set defaultJarsToSkip = new HashSet();
/**
* The string resources for this package.
*/
private static final StringManager sm =
StringManager.getManager(Constants.Package);
static {
String jarList = System.getProperty(Constants.SKIP_JARS_PROPERTY);
if (jarList != null) {
StringTokenizer tokenizer = new StringTokenizer(jarList, ",");
while (tokenizer.hasMoreElements()) {
defaultJarsToSkip.add(tokenizer.nextToken());
}
}
}
/**
* Controls the classpath scanning extension.
*/
private boolean scanClassPath = true;
public boolean isScanClassPath() {
return scanClassPath;
}
public void setScanClassPath(boolean scanClassPath) {
this.scanClassPath = scanClassPath;
}
/**
* Controls the testing all files to see of they are JAR files extension.
*/
private boolean scanAllFiles = false;
public boolean isScanAllFiles() {
return scanAllFiles;
}
public void setScanAllFiles(boolean scanAllFiles) {
this.scanAllFiles = scanAllFiles;
}
/**
* Controls the testing all directories to see of they are exploded JAR
* files extension.
*/
private boolean scanAllDirectories = false;
public boolean isScanAllDirectories() {
return scanAllDirectories;
}
public void setScanAllDirectories(boolean scanAllDirectories) {
this.scanAllDirectories = scanAllDirectories;
}
/**
* Scan the provided ServletContext and classloader for JAR files. Each JAR
* file found will be passed to the callback handler to be processed.
*
* @param context The ServletContext - used to locate and access
* WEB-INF/lib
* @param classloader The classloader - used to access JARs not in
* WEB-INF/lib
* @param callback The handler to process any JARs found
* @param jarsToSkip List of JARs to ignore. If this list is null, a
* default list will be read from the system property
* defined by {@link Constants#SKIP_JARS_PROPERTY}
*/
@Override
public void scan(ServletContext context, ClassLoader classloader,
JarScannerCallback callback, Set jarsToSkip) {
if (log.isTraceEnabled()) {
log.trace(sm.getString("jarScan.webinflibStart"));
}
Set ignoredJars;
if (jarsToSkip == null) {
ignoredJars = defaultJarsToSkip;
} else {
ignoredJars = jarsToSkip;
}
Set ignoredJarsTokens = new HashSet();
for (String pattern: ignoredJars) {
ignoredJarsTokens.add(Matcher.tokenizePathAsArray(pattern));
}
// Scan WEB-INF/lib
Set dirList = context.getResourcePaths(Constants.WEB_INF_LIB);
if (dirList != null) {
Iterator it = dirList.iterator();
while (it.hasNext()) {
String path = it.next();
if (path.endsWith(Constants.JAR_EXT) &&
!Matcher.matchPath(ignoredJarsTokens,
path.substring(path.lastIndexOf('/')+1))) {
// Need to scan this JAR
if (log.isDebugEnabled()) {
log.debug(sm.getString("jarScan.webinflibJarScan", path));
}
URL url = null;
try {
url = context.getResource(path);
process(callback, url);
} catch (IOException e) {
log.warn(sm.getString("jarScan.webinflibFail", url), e);
}
} else {
if (log.isTraceEnabled()) {
log.trace(sm.getString("jarScan.webinflibJarNoScan", path));
}
}
}
}
// Scan the classpath
if (scanClassPath) {
if (log.isTraceEnabled()) {
log.trace(sm.getString("jarScan.classloaderStart"));
}
ClassLoader loader =
Thread.currentThread().getContextClassLoader();
while (loader != null) {
if (loader instanceof URLClassLoader) {
URL[] urls = ((URLClassLoader) loader).getURLs();
for (int i=0; i