ChainHandler is initialized. When an HTTP request is
* received by this ChainHandler, each of the handlers from the
* list is called in turn until one of them responds and returns
* true.
*
* A useful trick is that some handlers can be run by a
* ChainHandler for their side effects. The handler can modify
* the Request object and then return false; the
* next handler in the list will get a crack at the modified request.
*
* The following configuration parameters eare used to initialize this
* Handler:
handlers
* Handler names that will be invoked in the
* given order to handle the request. These are considered the
* "wrapped" handlers. These handlers will all be initialized at
* startup by {@link #init}. For each name in the list, the property
* name.class is examined to determine which class
* to use for this handler. Then name is used as the prefix
* in the handler's init() method.
* report
* exitOnError
* initFailure will set
* any of the handlers fail to
* initialize. No handler prefix is required.
* prefix, suffix, glob, match
* handlers as specified by the
* configuration parameters. Used for logging the names of each
* Handler as it is invoked.
*/
public String[] names;
/**
* The prefix used to initialize this ChainHandler, used
* for logging.
*/
public String prefix;
/**
* The URL that must match for this handler to run
*/
public MatchString isMine;
/**
* The name (if any) of the property to receive the name of the handler
* that handled the request.
*/
public String report;
/**
* A flag to require the successfull initialization of all
* handlers.
*/
public boolean exitOnError = false;
/**
* Initializes this ChainHandler by initializing all the
* "wrapped" handlers in the list of handlers. If a wrapped handler
* cannot be initialized, this method logs a message and skips it. If no
* handlers were specified, or no handlers were successfully initialized,
* then the initialization of this ChainHandler is
* considered to have failed.
*
* @param server
* The HTTP server that created this ChainHandler.
*
* @param prefix
* The prefix for this ChainHandler's properties.
*
* @return true if at least one of the wrapped handlers
* was successfully initialized.
*/
public boolean
init(Server server, String prefix)
{
this.prefix = prefix;
isMine = new MatchString(prefix, server.props);
Properties props = server.props;
exitOnError = (props.getProperty(prefix + EXIT_ON_ERROR,
(props.getProperty(EXIT_ON_ERROR))) != null);
String str = props.getProperty(prefix + HANDLERS, "");
report = props.getProperty(prefix + "report");
StringTokenizer names = new StringTokenizer(str);
Vector handlerVec = new Vector();
Vector nameVec = new Vector();
while (names.hasMoreTokens()) {
String name = names.nextToken();
server.log(Server.LOG_DIAGNOSTIC, prefix,
"starting handler: " + name);
Handler h = initHandler(server, prefix, name);
if (h != null) {
handlerVec.addElement(h);
nameVec.addElement(name);
} else if (exitOnError) {
server.initFailure=true;
System.err.println("Handler initialization failure in (" +
prefix + ") for handler: " + name);
}
}
if (handlerVec.size() == 0) {
server.log(Server.LOG_DIAGNOSTIC, prefix, "no handlers");
return false;
}
this.handlers = new Handler[handlerVec.size()];
handlerVec.copyInto(this.handlers);
this.names = new String[nameVec.size()];
nameVec.copyInto(this.names);
return true;
}
/**
* Helper function that allocates and initializes a new
* Handler, given its name. In addition to the
* ChainHandler, several other handlers
* contain embedded Handlers -- this method can be
* used to initialize those embedded Handlers.
*
* If there is an error initializing the specified Handler,
* this method will log a dignostic message to the server and return
* null. This happens if the specified class cannot be
* found or instantiated, if the specified class is not actually a
* Handler, if the Handler.init method
* returns false, or if there is any other exception.
*
* @param server
* The server that will own the new Handler.
* Mainly used for the server's properties, which contain
* the configuration parameters for the new handler.
*
* @param prefix
* The prefix in the server's properties for the new
* Handler's configuration parameters. The prefix
* is prepended to the configuation parameters used by the
* Handler.
*
* @param name
* The name of the new Handler. The name can
* be one of two forms:
Handler.
* This Handler will be initialized using the
* prefix specified above.
*
* name. The configuration
* parameter name.class is the name of the
* Java class for the Handler. The above
* prefix will be ignored and this
* Handler will be initialized with the prefix
* "name." (the symbolic name followed by
* a ".").
* Handler, or null
* if the Handler could not be allocated.
*/
public static Handler
initHandler(Server server, String prefix, String name)
{
String className = server.props.getProperty(name + ".class");
if (className == null) {
className = name;
} else {
prefix = null;
}
if (prefix == null) {
prefix = name + ".";
}
try {
Handler h = (Handler) Class.forName(className.trim()).newInstance();
if (h.init(server, prefix)) {
return h;
}
server.log(Server.LOG_WARNING, name, "handler did not initialize");
} catch (ClassNotFoundException e) {
server.log(Server.LOG_WARNING, name, className + ": " + e);
} catch (NoClassDefFoundError e) {
server.log(Server.LOG_WARNING, name, className + ": " + e);
} catch (IllegalArgumentException e) {
server.log(Server.LOG_WARNING, className,
"Invalid argument during instantiation");
} catch (ClassCastException e) {
server.log(Server.LOG_WARNING, className, "is not a Handler");
} catch (Exception e) {
server.log(Server.LOG_WARNING, name, "error initializing:" + e);
e.printStackTrace();
}
return null;
}
/**
* Calls each of the Handlers in turn until one of them
* returns true.
*
* @param request
* The HTTP request.
*
* @return true if one of the Handlers returns
* true, false otherwise.
*
* @throws IOException
* if one of the Handlers throws an
* IOException while responding.
*/
public boolean
respond(Request request) throws IOException {
if (!isMine.match(request.url)) {
return false;
}
for (int i = 0; i < handlers.length; i++) {
request.log(Server.LOG_DIAGNOSTIC, prefix,
"invoking handler: " + names[i]);
if (handlers[i].respond(request)) {
if (report != null) {
request.log(Server.LOG_INFORMATIONAL, prefix, names[i] +
" handled: " + request.url);
request.props.put(report, names[i]);
}
return true;
}
}
return false;
}
}