/*
* Copyright 2006 Google Inc.
*
* Licensed 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 com.google.gwt.dev.shell.tomcat;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.dev.resource.Resource;
import com.google.gwt.dev.resource.impl.ClassPathEntry;
import com.google.gwt.dev.resource.impl.PathPrefix;
import com.google.gwt.dev.resource.impl.PathPrefixSet;
import com.google.gwt.dev.resource.impl.ResourceOracleImpl;
import com.google.gwt.dev.shell.WorkDirs;
import com.google.gwt.dev.util.Util;
import org.apache.catalina.Connector;
import org.apache.catalina.ContainerEvent;
import org.apache.catalina.ContainerListener;
import org.apache.catalina.Engine;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.Logger;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.startup.Embedded;
import org.apache.catalina.startup.HostConfig;
import org.apache.coyote.tomcat5.CoyoteConnector;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Collections;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
/**
* Wraps an instance of the Tomcat web server used in hosted mode.
*/
public class EmbeddedTomcatServer {
static EmbeddedTomcatServer sTomcat;
public static int getPort() {
return sTomcat.port;
}
public static String start(TreeLogger topLogger, int port, WorkDirs workDirs) {
return start(topLogger, port, workDirs, true);
}
public static synchronized String start(TreeLogger topLogger, int port,
WorkDirs workDirs, boolean shouldAutoGenerateResources) {
if (sTomcat != null) {
throw new IllegalStateException("Embedded Tomcat is already running");
}
try {
new EmbeddedTomcatServer(topLogger, port, workDirs,
shouldAutoGenerateResources);
return null;
} catch (LifecycleException e) {
String msg = e.getMessage();
if (msg != null && msg.indexOf("already in use") != -1) {
msg = "Port "
+ port
+ " is already is use; you probably still have another session active";
} else {
msg = "Unable to start the embedded Tomcat server; double-check that your configuration is valid";
}
return msg;
}
}
// Stop the embedded Tomcat server.
//
public static synchronized void stop() {
if (sTomcat != null) {
try {
sTomcat.catEmbedded.stop();
} catch (LifecycleException e) {
// There's nothing we can really do about this and the logger is
// gone in many scenarios, so we just ignore it.
//
} finally {
sTomcat = null;
}
}
}
/**
* Returns what local port the Tomcat connector is running on.
*
* When starting Tomcat with port 0 (i.e. choose an open port), there is just
* no way to figure out what port it actually chose. So we're using pure
* hackery to steal the port via reflection. The only works because we bundle
* Tomcat with GWT and know exactly what version it is.
*/
private static int computeLocalPort(Connector connector) {
Throwable caught = null;
try {
Field phField = CoyoteConnector.class.getDeclaredField("protocolHandler");
phField.setAccessible(true);
Object protocolHandler = phField.get(connector);
Field epField = protocolHandler.getClass().getDeclaredField("ep");
epField.setAccessible(true);
Object endPoint = epField.get(protocolHandler);
Field ssField = endPoint.getClass().getDeclaredField("serverSocket");
ssField.setAccessible(true);
ServerSocket serverSocket = (ServerSocket) ssField.get(endPoint);
return serverSocket.getLocalPort();
} catch (SecurityException e) {
caught = e;
} catch (NoSuchFieldException e) {
caught = e;
} catch (IllegalArgumentException e) {
caught = e;
} catch (IllegalAccessException e) {
caught = e;
}
throw new RuntimeException(
"Failed to retrieve the startup port from Embedded Tomcat", caught);
}
private Embedded catEmbedded;
private Engine catEngine;
private StandardHost catHost = null;
private int port;
private final TreeLogger startupBranchLogger;
private EmbeddedTomcatServer(final TreeLogger topLogger, int listeningPort,
final WorkDirs workDirs, final boolean shouldAutoGenerateResources)
throws LifecycleException {
if (topLogger == null) {
throw new NullPointerException("No logger specified");
}
final TreeLogger logger = topLogger.branch(TreeLogger.INFO,
"Starting HTTP on port " + listeningPort, null);
startupBranchLogger = logger;
// Make myself the one static instance.
// NOTE: there is only one small implementation reason that this has
// to be a singleton, which is that the commons logger LogFactory insists
// on creating your logger class which must have a constructor with
// exactly one String argument, and since we want LoggerAdapter to delegate
// to the logger instance available through instance host, there is no
// way I can think of to delegate without accessing a static field.
// An inner class is almost right, except there's no outer instance.
//
sTomcat = this;
// Assume the working directory is simply the user's current directory.
//
File topWorkDir = new File(System.getProperty("user.dir"));
// Tell Tomcat its base directory so that it won't complain.
//
String catBase = System.getProperty("catalina.base");
if (catBase == null) {
// we (briefly) supported catalina.base.create, so let's not cut support
// until the deprecated sunset
catBase = System.getProperty("catalina.base.create");
if (catBase != null) {
logger.log(TreeLogger.WARN, "catalina.base.create is deprecated. " +
"Use catalina.base, and it will be created if necessary.");
topWorkDir = new File(catBase);
}
catBase = generateDefaultCatalinaBase(logger, topWorkDir);
System.setProperty("catalina.base", catBase);
}
// Some debug messages for ourselves.
//
if (logger.isLoggable(TreeLogger.DEBUG)) {
logger.log(TreeLogger.DEBUG, "catalina.base = " + catBase, null);
}
// Set up the logger that will be returned by the Commons logging factory.
//
String adapterClassName = CommonsLoggerAdapter.class.getName();
System.setProperty("org.apache.commons.logging.Log", adapterClassName);
// And set up an adapter that will work with the Catalina logger family.
//
Logger catalinaLogger = new CatalinaLoggerAdapter(topLogger);
// Create an embedded server.
//
catEmbedded = new Embedded();
catEmbedded.setDebug(0);
catEmbedded.setLogger(catalinaLogger);
// The embedded engine is called "gwt".
//
catEngine = catEmbedded.createEngine();
catEngine.setName("gwt");
catEngine.setDefaultHost("localhost");
catEngine.setParentClassLoader(this.getClass().getClassLoader());
// It answers localhost requests.
//
// String appBase = fCatalinaBaseDir.getAbsolutePath();
String appBase = catBase + "/webapps";
catHost = (StandardHost) catEmbedded.createHost("localhost", appBase);
// Hook up a host config to search for and pull in webapps.
//
HostConfig hostConfig = new HostConfig();
catHost.addLifecycleListener(hostConfig);
// Hook pre-install events so that we can add attributes to allow loaded
// instances to find their development instance host.
//
catHost.addContainerListener(new ContainerListener() {
public void containerEvent(ContainerEvent event) {
if (StandardHost.PRE_INSTALL_EVENT.equals(event.getType())) {
StandardContext webapp = (StandardContext) event.getData();
publishShellLoggerAttribute(logger, topLogger, webapp);
publishShellWorkDirsAttribute(logger, workDirs, webapp);
publishShouldAutoGenerateResourcesAttribute(logger,
shouldAutoGenerateResources, webapp);
}
}
});
// Tell the engine about the host.
//
catEngine.addChild(catHost);
catEngine.setDefaultHost(catHost.getName());
// Tell the embedded manager about the engine.
//
catEmbedded.addEngine(catEngine);
InetAddress nullAddr = null;
Connector connector = catEmbedded.createConnector(nullAddr, listeningPort,
false);
catEmbedded.addConnector(connector);
// start up!
catEmbedded.start();
port = computeLocalPort(connector);
if (port != listeningPort) {
if (logger.isLoggable(TreeLogger.INFO)) {
logger.log(TreeLogger.INFO, "HTTP listening on port " + port, null);
}
}
}
public TreeLogger getLogger() {
return startupBranchLogger;
}
/*
* Assumes that the leaf is a file (not a directory).
*/
private void copyFileNoOverwrite(TreeLogger logger, String srcResName,
Resource srcRes, File catBase) {
File dest = new File(catBase, srcResName);
try {
// Only copy if src is newer than desc.
long srcLastModified = srcRes.getLastModified();
long dstLastModified = dest.lastModified();
if (srcLastModified < dstLastModified) {
// Don't copy over it.
if (logger.isLoggable(TreeLogger.SPAM)) {
logger.log(TreeLogger.SPAM, "Source is older than existing: "
+ dest.getAbsolutePath(), null);
}
return;
} else if (srcLastModified == dstLastModified) {
// Exact same time; quietly don't overwrite.
return;
} else if (dest.exists()) {
// Warn about the overwrite
logger.log(TreeLogger.WARN, "Overwriting existing file '"
+ dest.getAbsolutePath() + "' with '" + srcRes.getLocation()
+ "', which has a newer timestamp");
}
// Make dest directories as required.
File destParent = dest.getParentFile();
if (destParent != null) {
// No need to check mkdirs result because IOException later anyway.
destParent.mkdirs();
}
Util.copy(srcRes.openContents(), new FileOutputStream(dest));
dest.setLastModified(srcLastModified);
if (logger.isLoggable(TreeLogger.TRACE)) {
logger.log(TreeLogger.TRACE, "Wrote: " + dest.getAbsolutePath(), null);
}
} catch (IOException e) {
logger.log(TreeLogger.WARN, "Failed to write: " + dest.getAbsolutePath(),
e);
}
}
/**
* Extracts a valid catalina base instance from the classpath. Does not
* overwrite any existing files.
*/
private String generateDefaultCatalinaBase(TreeLogger logger, File workDir) {
logger = logger.branch(
TreeLogger.TRACE,
"Property 'catalina.base' not specified; checking for a standard catalina base image instead",
null);
// Recursively copies out files and directories
String tomcatEtcDir = "com/google/gwt/dev/etc/tomcat/";
Map<String, Resource> resourceMap = null;
Throwable caught = null;
try {
resourceMap = getResourcesFor(logger, tomcatEtcDir);
} catch (URISyntaxException e) {
caught = e;
} catch (IOException e) {
caught = e;
}
File catBase = new File(workDir, "tomcat");
if (resourceMap == null || resourceMap.isEmpty()) {
logger.log(TreeLogger.WARN, "Could not find " + tomcatEtcDir, caught);
} else {
for (Entry<String, Resource> entry : resourceMap.entrySet()) {
copyFileNoOverwrite(logger, entry.getKey(), entry.getValue(), catBase);
}
}
return catBase.getAbsolutePath();
}
/**
* Hacky, but fast.
*/
private Map<String, Resource> getResourcesFor(TreeLogger logger,
String tomcatEtcDir) throws URISyntaxException, IOException {
ClassLoader contextClassLoader = this.getClass().getClassLoader();
URL url = contextClassLoader.getResource(tomcatEtcDir);
if (url == null) {
return null;
}
String prefix = "";
String urlString = url.toString();
if (urlString.startsWith("jar:")) {
assert urlString.toLowerCase(Locale.ENGLISH).contains(".jar!/"
+ tomcatEtcDir);
urlString = urlString.substring(4, urlString.indexOf('!'));
url = new URL(urlString);
prefix = tomcatEtcDir;
} else if (urlString.startsWith("zip:")) {
assert urlString.toLowerCase(Locale.ENGLISH).contains(".zip!/"
+ tomcatEtcDir);
urlString = urlString.substring(4, urlString.indexOf('!'));
url = new URL(urlString);
prefix = tomcatEtcDir;
}
ClassPathEntry entry = ResourceOracleImpl.createEntryForUrl(logger, url);
assert (entry != null);
ResourceOracleImpl resourceOracle = new ResourceOracleImpl(
Collections.singletonList(entry));
PathPrefixSet pathPrefixSet = new PathPrefixSet();
PathPrefix pathPrefix = new PathPrefix(prefix, null, true);
pathPrefixSet.add(pathPrefix);
resourceOracle.setPathPrefixes(pathPrefixSet);
ResourceOracleImpl.refresh(logger, resourceOracle);
Map<String, Resource> resourceMap = resourceOracle.getResourceMap();
return resourceMap;
}
private void publishAttributeToWebApp(TreeLogger logger,
StandardContext webapp, String attrName, Object attrValue) {
if (logger.isLoggable(TreeLogger.TRACE)) {
logger.log(TreeLogger.TRACE, "Adding attribute '" + attrName
+ "' to web app '" + webapp.getName() + "'", null);
}
webapp.getServletContext().setAttribute(attrName, attrValue);
}
/**
* Publish the shell's tree logger as an attribute. This attribute is used to
* find the logger out of the thin air within the shell servlet.
*/
private void publishShellLoggerAttribute(TreeLogger logger,
TreeLogger loggerToPublish, StandardContext webapp) {
final String attr = "com.google.gwt.dev.shell.logger";
publishAttributeToWebApp(logger, webapp, attr, loggerToPublish);
}
/**
* Publish the shell's work dir as an attribute. This attribute is used to
* find it out of the thin air within the shell servlet.
*/
private void publishShellWorkDirsAttribute(TreeLogger logger,
WorkDirs workDirs, StandardContext webapp) {
final String attr = "com.google.gwt.dev.shell.workdirs";
publishAttributeToWebApp(logger, webapp, attr, workDirs);
}
/**
* Publish to the web app whether it should automatically generate resources.
*/
private void publishShouldAutoGenerateResourcesAttribute(TreeLogger logger,
boolean shouldAutoGenerateResources, StandardContext webapp) {
publishAttributeToWebApp(logger, webapp,
"com.google.gwt.dev.shell.shouldAutoGenerateResources",
shouldAutoGenerateResources);
}
}