MultiHostHandler allows the user to handle a set
* of host names that are all running on the same IP address. This
* handler looks at the http "Host" header and redispatches the request to the
* appropriate sub-server.
* * Only the main server is actually listening to the port on the specified IP * address. The sub-servers are not running in separate threads. Indeed, * they are not "running" at all. They exist merely as a convenient bag to * hold each of the server-specific configuration parameters. *
* The respond method of the main handler for the appropriate
* sub-server is called directly from the respond method of
* this handler.
*
* This handler uses the following configuration parameters:
server.props with the
* specified prefix. In this way, the configuration parameters for
* all the sub-servers can be stored in the same Properties
* object.
*
* FileHandler.
*
* * The property "root", if included in the "config" file, is treated * specially: If it does not represent an absolute path, then it is * resolved relative to the main server's root. *
* handler=host * port=8081 * log=5 * * host.class=sunlabs.brazil.server.MultiHostHandler * host.servers=mars jupiter saturn * * mars.host=www.mars.com * mars.log=2 * mars.handler=mars.file * mars.file.class=sunlabs.brazil.server.FileHandler * mars.file.root=public_html/mars * * jupiter.host=jupiter.planet.org * jupiter.handler=sunlabs.brazil.server.FileHandler * jupiter.root=public_html/jupiter * * saturn.host=*.saturn.planet.org * saturn.handler=sunlabs.brazil.server.FileHandler * saturn.root=public_html/saturn ** These parameters set up a normal
Server on port 8081,
* running a MultiHostHandler. The MultiHostHandler
* will create three additional servers that respond to the virtual hosts
* "www.mars.com", "jupiter.planet.org", and "Server.prefix of "mars",
* so that all other configuration parameters that the "mars" server
* examines can begin with "mars" and be kept distinct from the "jupiter"
* and "saturn" parameters.
* * The main server and the three sub-servers will all share the * same properties object, but can use their own individual prefixes to * keep their data separate (because "inherit" is not set). *
*
* @author Colin Stevens (colin.stevens@sun.com)
* @version 2.6, 07/01/29
*/
public class MultiHostHandler implements Handler {
String prefix;
private Vector servers = new Vector();
/**
* Initializes the servers for the virtual hosts. After creating
* and initializing each sub-server, the init method of the
* main handler for each sub-server is called.
*
* @param server
* The HTTP server that created this handler.
*
* @param prefix
* A prefix to prepend to all of the keys that this
* handler uses to extract configuration information.
*
* @return true if at least one sub-server was found and
* could be initialized, false otherwise.
* Diagnostic messages are logged for each sub-server started.
*/
public boolean
init(Server server, String prefix) {
this.prefix = prefix;
Properties props = server.props;
String list = props.getProperty(prefix + "servers", "");
StringTokenizer st = new StringTokenizer(list);
while (st.hasMoreTokens()) {
String name = st.nextToken();
server.log(Server.LOG_DIAGNOSTIC, prefix,
"creating subserver " + name);
Server sub = subServer(server, name);
if (sub!=null && sub.init()) {
servers.addElement(new Host(sub.hostName, sub));
}
}
return (servers.size() > 0);
}
/*
* Create a sub-server.
* @param main: The main server
* @param name: name of the sub-server
*/
Server subServer(Server main, String name) {
Properties props = main.props;
String handler = props.getProperty(name + ".handler",
FileHandler.class.getName());
String config = props.getProperty(name + ".config");
if (config != null) {
try {
InputStream in = ResourceHandler.getResourceStream(props,
"", config);
props = new Properties(props);
props.load(in);
in.close();
main.log(Server.LOG_DIAGNOSTIC, name,
"Fetching config file: " + config + " for " + name);
} catch (IOException e) {
main.log(Server.LOG_WARNING, name,
"Can't find config (" + config + ") for (" + name + ")");
return null;
}
// fix up the root
String mainroot = main.props.getProperty("root",".");
String root = (String)props.get("root");
if (root != null) {
File froot = new File(root);
if (!froot.isAbsolute()) {
froot = new File(mainroot, root);
}
props.put("root", froot.getPath());
main.log(Server.LOG_DIAGNOSTIC, name,
"Setting root for: " + name + " to " +
froot.getPath());
}
}
Server sub = new Server(main.listen, handler, props);
sub.hostName = props.getProperty(name + ".host", name);
sub.prefix = name;
if (!name.endsWith(".")) {
sub.prefix += ".";
}
try {
String str = props.getProperty(name + ".log");
sub.logLevel = Integer.decode(str).intValue();
} catch (Exception e) {
sub.logLevel = main.logLevel;
}
sub.maxRequests = main.maxRequests;
sub.timeout = main.timeout;
return sub;
}
/**
* Responds to an HTTP request by examining the "Host:" request header
* and dispatching to the main handler of the server that handles
* that virtual host. If the "Host:" request header was not specified,
* or named a virtual host that was not initialized in init
* from the list of virtual hosts, this method returns without
* handling the request. Port numbers are not used for host matching.
*
* @param request
* The HTTP request to be forwarded to one of the sub-servers.
*
* @return true if the sub-server handled the message,
* false if it did not. false is
* also returned if the "Host:" was unspecified or unknown.
*/
public boolean
respond(Request request) throws IOException {
String host = request.getRequestHeader("Host");
Server orig = request.server;
if (host == null) {
return false;
}
int idx = host.indexOf(":");
if (idx > 0) {
host = host.substring(0, idx);
}
for(int i=0;i