/*
* 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.loader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;
/**
* Boostrap loader for Catalina or other java apps.
*
* This application constructs a class loader
* for use in loading the Catalina internal classes (by accumulating all of the
* JAR files found in the "server" directory under "catalina.home"), and
* starts the regular execution of the container. The purpose of this
* roundabout approach is to keep the Catalina internal classes (and any
* other classes they depend on, such as an XML parser) out of the system
* class path and therefore not visible to application level classes.
*
*
* Merged with CatalinaProperties:
* Load a properties file describing the modules and startup sequence.
* This is responsible for configuration of the loader.
* TODO: support jmx-style configuration, including persistence.
* TODO: better separate legacy config and the new style
*
* The properties file will be named "loader.properties" or
* "catalina.properties" ( for backwad compatibility ) and
* will be searched in:
* - TODO
*
* Properties used:
* - TODO
*
* loader.* and *.loader properties are used internally by the loader (
* *.loader is for backward compat with catalina ).
* All other properties in the config file are set as System properties.
*
* Based on o.a.catalina.bootstrap.CatalinaProperties - utility class to read
* the bootstrap Catalina configuration.
*
* @author Craig R. McClanahan
* @author Remy Maucherat
* @author Costin Manolache
*/
public final class Loader {
private static final boolean DEBUG=true; //LoaderProperties.getProperty("loader.debug.Loader") != null;
// If flat, only one loader is created. If false - one loader per jar/dir
private static final boolean FLAT=false;//LoaderProperties.getProperty("loader.Loader.flat") != null;
// -------------------------------------------------------------- Constants
private static final String CATALINA_HOME_TOKEN = "${catalina.home}";
private static final String CATALINA_BASE_TOKEN = "${catalina.base}";
// ------------------------------------------------------- Static Variables
/**
* Daemon object used by main.
*/
private static Loader daemon = null;
// one should be enough
ModuleListener listener;
// -------------------------------------------------------------- Variables
protected Repository commonRepository = null;
protected Repository catalinaRepository = null;
protected Repository sharedRepository = null;
protected ClassLoader catalinaLoader = null;
private String[] args;
private Hashtable repositories=new Hashtable();
private ClassLoader parentClassLoader;
private static Properties properties = null;
private static String propFile;
// -------------------------------------------------------- Private Methods
/** Set the parent class loader - can be used instead of setParent,
* in case this is the top loader and needs to delagate to embedding app.
* The common loader will delegate to this loader
*
* @param myL
*/
public void setParentClassLoader(ClassLoader myL) {
this.parentClassLoader=myL;
}
/** Initialize the loader, creating all repositories.
* Will create common, server, shared.
*
* TODO: create additional repos.
*
*/
public void init() {
try {
commonRepository = initRepository("common", null, parentClassLoader);
catalinaRepository = initRepository("server", commonRepository,null);
catalinaLoader = catalinaRepository.getClassLoader();
sharedRepository = initRepository("shared", commonRepository,null);
} catch (Throwable t) {
log("Class loader creation threw exception", t);
System.exit(1);
}
}
/** Create a new repository.
* No Module is added ( currently )
* TODO: use props to prepopulate, if any is present.
*
* @param name
* @param parent
* @return
*/
public Repository createRepository(String name, Repository parent) {
Repository lg=new Repository(this);
lg.setName(name);
lg.setParent( parent );
repositories.put(name, lg);
if( listener != null ) {
listener.repositoryAdd(lg);
}
return lg;
}
public Enumeration getRepositoryNames() {
return repositories.keys();
}
/** Create a module using the NAME.loader property to construct the
* classpath.
*
* @param name
* @param parent
* @return
* @throws Exception
*/
private Repository initRepository(String name, Repository parent, ClassLoader pcl)
throws Exception
{
String value = getProperty(name + ".loader");
Repository lg=createRepository(name, parent );
if( pcl != null )
lg.setParentClassLoader( pcl );
if( DEBUG ) log( "Creating loading group " + name + " - " + value + " " + pcl);
if ((value == null) || (value.equals("")))
return lg;
ArrayList unpackedList = new ArrayList();
ArrayList packedList = new ArrayList();
ArrayList urlList = new ArrayList();
Vector repo=split( value );
Enumeration elems=repo.elements();
while (elems.hasMoreElements()) {
String repository = (String)elems.nextElement();
// Local repository
boolean packed = false;
if (repository.startsWith(CATALINA_HOME_TOKEN)) {
repository = getCatalinaHome()
+ repository.substring(CATALINA_HOME_TOKEN.length());
} else if (repository.startsWith(CATALINA_BASE_TOKEN)) {
repository = getCatalinaBase()
+ repository.substring(CATALINA_BASE_TOKEN.length());
}
// Check for a JAR URL repository
try {
urlList.add(new URL(repository));
continue;
} catch (MalformedURLException e) {
// Ignore
}
if (repository.endsWith("*.jar")) {
packed = true;
repository = repository.substring
(0, repository.length() - "*.jar".length());
}
if (packed) {
packedList.add(new File(repository));
} else {
unpackedList.add(new File(repository));
}
}
File[] unpacked = (File[]) unpackedList.toArray(new File[0]);
File[] packed = (File[]) packedList.toArray(new File[0]);
URL[] urls = (URL[]) urlList.toArray(new URL[0]);
// previously: ClassLoaderFactory.createClassLoader
initRepository(lg, unpacked, packed, urls, parent); //new ModuleGroup();
// TODO: JMX registration for the group loader
/*
// Register the server classloader
ObjectName objectName =
new ObjectName("Catalina:type=ServerClassLoader,name=" + name);
mBeanServer.registerMBean(classLoader, objectName);
*/
return lg; // classLoader;
}
/** Small hack to allow a loader.properties file to be passed in CLI, to
* allow a more convenient method to start with different params from
* explorer/kde/etc.
*
* If the first arg ends with ".loader", it is used as loader.properties
* file and removed from args[].
*/
private void processCLI() {
if( args!=null && args.length > 0 &&
(args[0].toLowerCase().endsWith(".tomcat") ||
args[0].toLowerCase().endsWith(".loader") ||
args[0].toLowerCase().endsWith("loader.properties") )) {
String props=args[0];
String args2[]=new String[args.length-1];
System.arraycopy(args, 1, args2, 0, args2.length);
args=args2;
setPropertiesFile(props);
} else {
loadProperties();
}
}
/**
* Initialize:
* - detect the home/base directories
* - init the loaders / modules
* - instantiate the "startup" class(es)
*
*/
public void main()
throws Exception
{
processCLI();
// Set Catalina path
setCatalinaHome();
setCatalinaBase();
init();
Thread.currentThread().setContextClassLoader(catalinaLoader);
securityPreload(catalinaLoader);
autostart();
}
private void autostart() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
// Load our startup classes and call its process() method
/* Why multiple classes ?
* - maybe you want to start more "servers" ( tomcat ,something else )
* - easy hook for other load on startup modules ( like a jmx hook )
* - maybe split the loader-specific code from catalina
*/
String startupClasses=getProperty("loader.auto-startup",
"org.apache.catalina.startup.CatalinaModuleListener");
Vector v=split( startupClasses );
for( int i=0; i<v.size(); i++ ) {
String startupCls=(String)v.elementAt(i);
if (DEBUG)
log("Loading startup class " + startupCls);
Class startupClass =
catalinaLoader.loadClass(startupCls);
Object startupInstance = startupClass.newInstance();
if( startupInstance instanceof ModuleListener ) {
addModuleListener((ModuleListener)startupInstance);
// it can get args[] and properties from Loader
listener.setLoader(this);
// all arg processing moved there. Maybe we can make it consistent
// for all startup schemes
listener.start();
} else if ( startupInstance instanceof Runnable ) {
((Runnable)startupInstance).run();
} else {
Class paramTypes[] = new Class[0];
Object paramValues[] = new Object[0];
Method method =
startupInstance.getClass().getMethod("execute", paramTypes);
if( method==null )
method = startupInstance.getClass().getMethod("start", paramTypes);
if( method!=null )
method.invoke(startupInstance, paramValues);
}
}
}
/** Returns one of the repositories.
*
* Typically at startup we create at least: "common", "shared" and "server", with
* same meaning as in tomcat.
*
* @param name
* @return
*/
public Repository getRepository( String name ) {
return (Repository)repositories.get(name);
}
private static void securityPreload(ClassLoader loader)
throws Exception {
if( System.getSecurityManager() == null ){
return;
}
String value=getProperty("security.preload");
Vector repo=split( value );
Enumeration elems=repo.elements();
while (elems.hasMoreElements()) {
String classN = (String)elems.nextElement();
try {
loader.loadClass( classN);
} catch( Throwable t ) {
// ignore
}
}
}
// ----------------------------------------------------------- Main Program
/** Access to the command line arguments, when Loader is used to launc an app.
*/
public String[] getArgs() {
return args;
}
/**
* Main method.
*
* @param args Command line arguments to be processed
*/
public static void main(String args[]) {
try {
if (daemon == null) {
daemon = new Loader();
daemon.args=args;
try {
daemon.main();
} catch (Throwable t) {
t.printStackTrace();
return;
}
}
} catch (Throwable t) {
t.printStackTrace();
}
}
/**
* Initialize the loader properties explicitely.
*
* TODO: add setPropertiesRes
*
* @param props
*/
public void setPropertiesFile(String props) {
propFile=props;
loadProperties();
}
/**
* Return specified property value.
*/
static String getProperty(String name) {
if( properties==null ) loadProperties();
return properties.getProperty(name);
}
/**
* Return specified property value.
*/
static String getProperty(String name, String defaultValue) {
if( properties==null ) loadProperties();
return properties.getProperty(name, defaultValue);
}
/**
* Load properties.
* Will try:
* - "catalina.config" system property ( a URL )
* - "catalina.base", "catalina.home", "user.dir" system properties +
* "/conf/" "../conf" "/" + "loader.properties" or "catalina.properties"
* - /org/apache/catalina/startup/catalina.properties
*
* Properties will be loaded as system properties.
*
* loader.properties was added to allow coexistence with bootstrap.jar ( the
* current scheme ), since the classpaths are slightly different.
*/
static void loadProperties() {
properties = new Properties();
InputStream is = null;
Throwable error = null;
// TODO: paste the code to do ${} substitution
// TODO: add the code to detect where tomcat-properties is loaded from
if( propFile != null ) {
try {
File properties = new File(propFile);
is = new FileInputStream(properties);
if( is!=null && DEBUG ) {
log("Loaded from loader.properties " + properties );
}
} catch( Throwable t) {
System.err.println("Can't find " + propFile);
return;
}
}
if( is == null ) {
try {
// "catalina.config" system property
String configUrl = System.getProperty("catalina.config");
if (configUrl != null) {
is = (new URL(configUrl)).openStream();
if( is!=null && DEBUG ) {
log("Loaded from catalina.config " + configUrl );
}
}
} catch (Throwable t) {
// Ignore
}
}
if( is == null ) {
try {
// "loader.config" system property
String configUrl = System.getProperty("loader.config");
if (configUrl != null) {
is = (new URL(configUrl)).openStream();
if( is!=null && DEBUG ) {
log("Loaded from catalina.config " + configUrl );
}
}
} catch (Throwable t) {
// Ignore
}
}
if (is == null) {
try {
setCatalinaBase(); // use system properties, then user.dir
File home = new File(getCatalinaBase());
File conf = new File(home, "conf");
// use conf if exists, or the base directory otherwise
if( ! conf.exists() ) conf = new File(home, "../conf");
if( ! conf.exists() ) conf = home;
File propertiesF=null;
if( conf.exists() )
propertiesF= new File(conf, "loader.properties");
if( ! propertiesF.exists() ) {
propertiesF= new File( home, "loader.properties");
}
if( propertiesF.exists() )
is = new FileInputStream(propertiesF);
if( is!=null && DEBUG ) {
log("Loaded from loader.properties " + properties );
}
} catch (Throwable t) {
// Ignore
}
}
if (is == null) {
try {
File home = new File(getCatalinaBase());
File conf = new File(home, "conf");
File properties = new File(conf, "catalina.properties");
is = new FileInputStream(properties);
if( is!=null && DEBUG ) {
log("Loaded from catalina.properties " + properties );
}
} catch (Throwable t) {
// Ignore
}
}
if (is == null) {
try {
is = Loader.class.getResourceAsStream
("/org/apache/catalina/startup/catalina.properties");
if( is!=null && DEBUG ) {
log("Loaded from o/a/c/startup/catalina.properties " );
}
} catch (Throwable t) {
// Ignore
}
}
if (is == null) {
try {
is = Loader.class.getResourceAsStream
("loader.properties");
if( is!=null && DEBUG ) {
log("Loaded from res loader.properties " );
}
} catch (Throwable t) {
// Ignore
}
}
if (is != null) {
try {
properties.load(is);
is.close();
} catch (Throwable t) {
error = t;
}
}
// if ((is == null) || (error != null)) {
// // Do something
// log("Error: no properties found !!!");
// }
// Register the _unused_ properties as system properties
if( properties != null ) {
Enumeration enumeration = properties.propertyNames();
while (enumeration.hasMoreElements()) {
String name = (String) enumeration.nextElement();
String value = properties.getProperty(name);
if( "security.preload".equals( name )) continue;
if( "package.access".equals( name )) continue;
if( "package.definition".equals( name )) continue;
if( name.endsWith(".loader")) continue;
if( name.startsWith("loader.")) continue;
if (value != null) {
System.setProperty(name, value);
}
}
}
}
static void setCatalinaHome(String s) {
System.setProperty( "catalina.home", s );
}
static void setCatalinaBase(String s) {
System.setProperty( "catalina.base", s );
}
/**
* Get the value of the catalina.home environment variable.
*
* @deprecated
*/
static String getCatalinaHome() {
if( properties==null ) loadProperties();
return System.getProperty("catalina.home",
System.getProperty("user.dir"));
}
/**
* Get the value of the catalina.base environment variable.
*
* @deprecated
*/
static String getCatalinaBase() {
if( properties==null ) loadProperties();
return System.getProperty("catalina.base", getCatalinaHome());
}
/**
* Set the <code>catalina.base</code> System property to the current
* working directory if it has not been set.
*/
static void setCatalinaBase() {
if( properties==null ) loadProperties();
if (System.getProperty("catalina.base") != null)
return;
if (System.getProperty("catalina.home") != null)
System.setProperty("catalina.base",
System.getProperty("catalina.home"));
else
System.setProperty("catalina.base",
System.getProperty("user.dir"));
}
/**
* Set the <code>catalina.home</code> System property to the current
* working directory if it has not been set.
*/
static void setCatalinaHome() {
if (System.getProperty("catalina.home") != null)
return;
File bootstrapJar =
new File(System.getProperty("user.dir"), "bootstrap.jar");
File tloaderJar =
new File(System.getProperty("user.dir"), "tomcat-loader.jar");
if (bootstrapJar.exists() || tloaderJar.exists()) {
try {
System.setProperty
("catalina.home",
(new File(System.getProperty("user.dir"), ".."))
.getCanonicalPath());
} catch (Exception e) {
// Ignore
System.setProperty("catalina.home",
System.getProperty("user.dir"));
}
} else {
System.setProperty("catalina.home",
System.getProperty("user.dir"));
}
}
/**
* Get the module from the classloader. Works only for classloaders created by
* this package - or extending ModuleClassLoader.
*
* This shold be the only public method that allows this - Loader acts as a
* guard, only if you have the loader instance you can access the internals.
*
*
* @param cl
* @return
*/
public Module getModule(ClassLoader cl ) {
if( cl instanceof ModuleClassLoader ) {
return ((ModuleClassLoader)cl).getModule();
}
return null;
}
/**
* Create and return a new class loader, based on the configuration
* defaults and the specified directory paths:
*
* @param unpacked Array of pathnames to unpacked directories that should
* be added to the repositories of the class loader, or <code>null</code>
* for no unpacked directories to be considered
* @param packed Array of pathnames to directories containing JAR files
* that should be added to the repositories of the class loader,
* or <code>null</code> for no directories of JAR files to be considered
* @param urls Array of URLs to remote repositories, designing either JAR
* resources or uncompressed directories that should be added to
* the repositories of the class loader, or <code>null</code> for no
* directories of JAR files to be considered
* @param parent Parent class loader for the new class loader, or
* <code>null</code> for the system class loader.
*
* @exception Exception if an error occurs constructing the class loader
*/
private void initRepository(Repository lg, File unpacked[],
File packed[], URL urls[], Repository parent)
throws Exception
{
StringBuffer sb=new StringBuffer();
// Construct the "class path" for this class loader
ArrayList list = new ArrayList();
// Add unpacked directories
if (unpacked != null) {
for (int i = 0; i < unpacked.length; i++) {
File file = unpacked[i];
if (!file.exists() || !file.canRead()) {
if (DEBUG)
log(" Not found: "+ file.getAbsolutePath());
continue;
}
// String cPath=file.getCanonicalPath();
// URL url=null;
//
// if( cPath.toLowerCase().endsWith(".jar") ||
// cPath.toLowerCase().endsWith(".zip") ) {
// url = new URL("file", null, cPath);
// } else {
// url = new URL("file", null, cPath + File.separator);
// }
URL url=file.toURL();
if (DEBUG)
sb.append(" : "+ url);
if( ! FLAT ) {
addLoader(lg, parent, new URL[] { url });
} else {
list.add(url);
}
}
}
// Add packed directory JAR files
if (packed != null) {
for (int i = 0; i < packed.length; i++) {
File directory = packed[i];
if (!directory.isDirectory() || !directory.exists() ||
!directory.canRead()) {
if (DEBUG)
log(" Not found: "+ directory.getAbsolutePath());
continue;
}
String filenames[] = directory.list();
for (int j = 0; j < filenames.length; j++) {
String filename = filenames[j].toLowerCase();
if (!filename.endsWith(".jar"))
continue;
File file = new File(directory, filenames[j]);
// if (DEBUG)
// sb.append(" [pak]="+ file.getCanonicalPath());
// URL url = new URL("file", null,
// file.getCanonicalPath());
URL url=file.toURL();
if (DEBUG)
sb.append(" pk="+ url);
if( ! FLAT ) {
addLoader(lg, parent, new URL[] { url });
} else {
list.add(url);
}
}
}
}
// Add URLs
if (urls != null) {
for (int i = 0; i < urls.length; i++) {
if( ! FLAT ) {
addLoader(lg, parent, new URL[] { urls[i] });
} else {
list.add(urls[i]);
}
if (DEBUG)
sb.append(" "+ urls[i]);
}
}
// Construct the class loader itself
// TODO: experiment with loading each jar in a separate loader.
if (DEBUG)
log("Creating new class loader " + lg.getName() + " " + sb.toString());
URL[] array = (URL[]) list.toArray(new URL[list.size()]);
if( array.length > 0 ) {
addLoader(lg, parent, array);
}
}
/**
* @param lg
* @param parent
* @param list
*/
private void addLoader(Repository lg, Repository parent, URL array[])
throws Exception
{
Module module=new Module();
module.setParent( parent );
module.setClasspath( array );
lg.addModule(module);
}
private static Vector split( String value ) {
Vector result=new Vector();
StringTokenizer tokenizer = new StringTokenizer(value, ",");
while (tokenizer.hasMoreElements()) {
String repository = tokenizer.nextToken();
repository.trim();
if( ! "".equals(repository) )
result.addElement(repository);
}
return result;
}
void notifyModuleStart(Module module) {
if(listener!=null) listener.moduleStart(module);
}
void notifyModuleStop(Module module) {
if( listener!=null ) listener.moduleStop(module);
}
/** Add a module listener.
*
* To keep the dependencies minimal, the loader package only implements the
* basic class loading mechanism - but any advanced feature ( management,
* policy, etc ) should be implemented by a module.
*
* @param listener
*/
public void addModuleListener(ModuleListener listener) {
this.listener=listener;
}
private static void log(String s) {
System.err.println("Main: " + s);
}
private static void log( String msg, Throwable t ) {
System.err.println("Main: " + msg);
t.printStackTrace();
}
}