Revert GWTShell and GWTCompiler change due to internal breakage.
Review by: andrewwarner@google.com
git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@11409 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/dev/build.xml b/dev/build.xml
index 08677ef..0ea5528 100755
--- a/dev/build.xml
+++ b/dev/build.xml
@@ -34,6 +34,7 @@
excludes="**/super/**">
<classpath>
<pathelement location="${javac.out}" />
+ <pathelement location="${gwt.tools.lib}/tomcat/servlet-api-2.5.jar" />
<pathelement location="${gwt.tools.lib}/junit/junit-4.8.2.jar" />
<pathelement location="${gwt.tools.lib}/jfreechart/jfreechart-1.0.3.jar" />
<pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
@@ -62,13 +63,33 @@
<include name="jetty/jetty-6.1.11.jar" />
<include name="icu4j/4.4.2/icu4j.jar" />
<include name="protobuf/protobuf-2.2.0/protobuf-java-rebased-2.2.0.jar" />
- <!-- dependencies needed for JSP support in DevMode: BEGIN -->
+ <include name="tomcat/ant-launcher-1.6.5.jar" />
+ <include name="tomcat/catalina-1.0.jar" />
+ <include name="tomcat/catalina-optional-1.0.jar" />
+ <include name="tomcat/commons-beanutils-1.6.jar" />
+ <include name="tomcat/commons-collections-3.1.jar" />
+ <include name="tomcat/commons-digester-1.5.jar" />
<include name="tomcat/commons-el-1.0.jar" />
+ <include name="tomcat/commons-logging-1.0.jar" />
+ <include name="tomcat/commons-modeler-1.1.jar" />
+ <include name="tomcat/jakarta-regexp-1.3.jar" />
<include name="tomcat/jasper-compiler-1.0.jar" />
<include name="tomcat/jasper-runtime-1.0.jar" />
<include name="tomcat/jsp-api-2.0.jar" />
- <!-- dependencies needed for JSP support in DevMode: END -->
- <include name="apache/commons/commons-collections-3.2.1.jar" />
+ <include name="tomcat/mx4j-jmx-1.1.jar" />
+ <include name="tomcat/naming-common-1.0.jar" />
+ <include name="tomcat/naming-factory-1.0.jar" />
+ <include name="tomcat/naming-java-1.0.jar" />
+ <include name="tomcat/naming-resources-1.0.jar" />
+ <include name="tomcat/servlet-api-2.5.jar" />
+ <include name="tomcat/servlet-api-2.4.jar" />
+ <include name="tomcat/servlets-common-1.0.jar" />
+ <include name="tomcat/servlets-default-1.0.jar" />
+ <include name="tomcat/servlets-invoker-1.0.jar" />
+ <include name="tomcat/tomcat-coyote-1.0.jar" />
+ <include name="tomcat/tomcat-http11-1.0.jar" />
+ <include name="tomcat/tomcat-jk2-2.1.jar" />
+ <include name="tomcat/tomcat-util-5.1.jar" />
<!-- htmlunit dependencies not already included: BEGIN -->
<include name="apache/http/httpclient-4.1.2.jar" />
<include name="apache/http/httpcore-4.1.2.jar" />
@@ -110,13 +131,33 @@
<zipfileset src="${gwt.tools.lib}/jetty/jetty-6.1.11.jar" />
<zipfileset src="${gwt.tools.lib}/icu4j/4.4.2/icu4j.jar" />
<zipfileset src="${gwt.tools.lib}/protobuf/protobuf-2.2.0/protobuf-java-rebased-2.2.0.jar" />
- <!-- dependencies needed for JSP support in DevMode: BEGIN -->
+ <zipfileset src="${gwt.tools.lib}/tomcat/ant-launcher-1.6.5.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/catalina-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/catalina-optional-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/commons-beanutils-1.6.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/commons-collections-3.1.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/commons-digester-1.5.jar" />
<zipfileset src="${gwt.tools.lib}/tomcat/commons-el-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/commons-logging-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/commons-modeler-1.1.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/jakarta-regexp-1.3.jar" />
<zipfileset src="${gwt.tools.lib}/tomcat/jasper-compiler-1.0.jar" />
<zipfileset src="${gwt.tools.lib}/tomcat/jasper-runtime-1.0.jar" />
<zipfileset src="${gwt.tools.lib}/tomcat/jsp-api-2.0.jar" />
- <!-- dependencies needed for JSP support in DevMode: END -->
- <zipfileset src="${gwt.tools.lib}/apache/commons/commons-collections-3.2.1.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/mx4j-jmx-1.1.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/naming-common-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/naming-factory-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/naming-java-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/naming-resources-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/servlet-api-2.5.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/servlet-api-2.4.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/servlets-common-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/servlets-default-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/servlets-invoker-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/tomcat-coyote-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/tomcat-http11-1.0.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/tomcat-jk2-2.1.jar" />
+ <zipfileset src="${gwt.tools.lib}/tomcat/tomcat-util-5.1.jar" />
<!-- htmlunit dependencies not already included: BEGIN -->
<zipfileset src="${gwt.tools.lib}/apache/http/httpclient-4.1.2.jar" />
<zipfileset src="${gwt.tools.lib}/apache/http/httpcore-4.1.2.jar" />
@@ -179,7 +220,7 @@
<classpath>
<pathelement location="${gwt.tools.lib}/apache/ant-1.6.5.jar" />
<pathelement location="${gwt.tools.lib}/eclipse/jdt-3.4.2_r894.jar" />
- <pathelement location="${gwt.tools.lib}/apache/commons/commons-collections-3.2.1.jar" />
+ <pathelement location="${gwt.tools.lib}/tomcat/commons-collections-3.1.jar" />
<pathelement location="${gwt.tools.lib}/guava/guava-10.0.1/guava-10.0.1-rebased.jar" />
<pathelement location="${gwt.tools.lib}/jscomp/r1649/compiler-rebased.jar" />
</classpath>
diff --git a/dev/core/src/com/google/gwt/dev/CompileTaskRunner.java b/dev/core/src/com/google/gwt/dev/CompileTaskRunner.java
index 914713d..7c65f6e 100644
--- a/dev/core/src/com/google/gwt/dev/CompileTaskRunner.java
+++ b/dev/core/src/com/google/gwt/dev/CompileTaskRunner.java
@@ -63,7 +63,7 @@
}
});
- compilerThread.setName("GWT Compiler Thread");
+ compilerThread.setName("GWTCompiler Thread");
compilerThread.start();
// TODO(jat): create an app frame for loggerWindow
diff --git a/dev/core/src/com/google/gwt/dev/GWTCompiler.java b/dev/core/src/com/google/gwt/dev/GWTCompiler.java
new file mode 100644
index 0000000..ef2e4ea
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/GWTCompiler.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright 2008 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;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.linker.ArtifactSet;
+import com.google.gwt.dev.CompileTaskRunner.CompileTask;
+import com.google.gwt.dev.cfg.ModuleDef;
+import com.google.gwt.dev.cfg.ModuleDefLoader;
+import com.google.gwt.dev.jjs.JJSOptions;
+import com.google.gwt.dev.jjs.PermutationResult;
+import com.google.gwt.dev.shell.CheckForUpdates;
+import com.google.gwt.dev.shell.CheckForUpdates.UpdateResult;
+import com.google.gwt.dev.util.FileBackedObject;
+import com.google.gwt.dev.util.Util;
+import com.google.gwt.dev.util.arg.ArgHandlerLocalWorkers;
+import com.google.gwt.dev.util.arg.ArgHandlerOutDir;
+import com.google.gwt.dev.util.arg.ArgHandlerWorkDirOptional;
+import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
+import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
+import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;
+import com.google.gwt.util.tools.ToolBase;
+import com.google.gwt.util.tools.Utility;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.FutureTask;
+
+/**
+ * The main executable entry point for the GWT Java to JavaScript compiler.
+ *
+ * @deprecated Use {@link Compiler} instead
+ */
+@Deprecated
+public class GWTCompiler {
+
+ static final class ArgProcessor extends PrecompileTaskArgProcessor {
+ public ArgProcessor(LegacyCompilerOptions options) {
+ super(options);
+
+ registerHandler(new ArgHandlerOutDir(options));
+
+ // Override the ArgHandlerWorkDirRequired in the super class.
+ registerHandler(new ArgHandlerWorkDirOptional(options));
+
+ registerHandler(new ArgHandlerLocalWorkers(options));
+ }
+
+ @Override
+ protected String getName() {
+ return GWTCompiler.class.getName();
+ }
+ }
+
+ /**
+ * Simple implementation of {@link LegacyCompilerOptions}.
+ */
+ public static class GWTCompilerOptionsImpl extends PrecompileTaskOptionsImpl
+ implements LegacyCompilerOptions {
+
+ private int localWorkers;
+ private File outDir;
+
+ public GWTCompilerOptionsImpl() {
+ }
+
+ public GWTCompilerOptionsImpl(LegacyCompilerOptions other) {
+ copyFrom(other);
+ }
+
+ public void copyFrom(LegacyCompilerOptions other) {
+ super.copyFrom(other);
+ setLocalWorkers(other.getLocalWorkers());
+ setOutDir(other.getOutDir());
+ }
+
+ @Override
+ public int getLocalWorkers() {
+ return localWorkers;
+ }
+
+ @Override
+ public File getOutDir() {
+ return outDir;
+ }
+
+ @Override
+ public void setLocalWorkers(int localWorkers) {
+ this.localWorkers = localWorkers;
+ }
+
+ @Override
+ public void setOutDir(File outDir) {
+ this.outDir = outDir;
+ }
+ }
+
+ public static void main(String[] args) {
+ ToolBase.legacyWarn(GWTCompiler.class, Compiler.class);
+ SpeedTracerLogger.init();
+ Event compileEvent = SpeedTracerLogger.start(CompilerEventType.COMPILE);
+
+ /*
+ * NOTE: main always exits with a call to System.exit to terminate any
+ * non-daemon threads that were started in Generators. Typically, this is to
+ * shutdown AWT related threads, since the contract for their termination is
+ * still implementation-dependent.
+ */
+ final LegacyCompilerOptions options = new GWTCompilerOptionsImpl();
+ boolean success = false;
+ if (new ArgProcessor(options).processArgs(args)) {
+ CompileTask task = new CompileTask() {
+ @Override
+ public boolean run(TreeLogger logger) throws UnableToCompleteException {
+ FutureTask<UpdateResult> updater = null;
+ if (!options.isUpdateCheckDisabled()) {
+ updater = CheckForUpdates.checkForUpdatesInBackgroundThread(logger,
+ CheckForUpdates.ONE_DAY);
+ }
+ boolean success = new GWTCompiler(options).run(logger);
+ if (success) {
+ CheckForUpdates.logUpdateAvailable(logger, updater);
+ }
+ return success;
+ }
+ };
+ if (CompileTaskRunner.runWithAppropriateLogger(options, task)) {
+ // Exit w/ success code.
+ success = true;
+ }
+ }
+
+ compileEvent.end();
+ // Exit w/ non-success code.
+ System.exit(success ? 0 : 1);
+ }
+
+ private final GWTCompilerOptionsImpl options;
+
+ public GWTCompiler(LegacyCompilerOptions options) {
+ this.options = new GWTCompilerOptionsImpl(options);
+ }
+
+ /**
+ * Compiles the set of modules specified in the options.
+ */
+ public boolean run(TreeLogger logger) throws UnableToCompleteException {
+ ModuleDef[] modules = new ModuleDef[options.getModuleNames().size()];
+ int i = 0;
+ for (String moduleName : options.getModuleNames()) {
+ modules[i++] = ModuleDefLoader.loadFromClassPath(logger, moduleName, true);
+ }
+ return run(logger, modules);
+ }
+
+ /**
+ * Compiles a specific set of modules.
+ */
+ public boolean run(TreeLogger logger, ModuleDef... modules)
+ throws UnableToCompleteException {
+ Event compileEvent = SpeedTracerLogger.start(CompilerEventType.COMPILE);
+ boolean tempWorkDir = false;
+ try {
+ if (options.getWorkDir() == null) {
+ options.setWorkDir(Utility.makeTemporaryDirectory(null, "gwtc"));
+ tempWorkDir = true;
+ }
+
+ for (ModuleDef module : modules) {
+ String moduleName = module.getName();
+
+ if (options.isValidateOnly()) {
+ if (!Precompile.validate(logger, options, module, options.getGenDir())) {
+ return false;
+ }
+ } else {
+ long compileStart = System.currentTimeMillis();
+ logger = logger.branch(TreeLogger.INFO, "Compiling module "
+ + moduleName);
+
+ // Optimize early since permutation compiles will run in process.
+ options.setOptimizePrecompile(true);
+ Precompilation precompilation = Precompile.precompile(logger,
+ options, module, options.getGenDir());
+
+ if (precompilation == null) {
+ return false;
+ }
+ Permutation[] allPerms = precompilation.getPermutations();
+ List<FileBackedObject<PermutationResult>> resultFiles = CompilePerms.makeResultFiles(
+ options.getCompilerWorkDir(moduleName), allPerms);
+ CompilePerms.compile(logger, precompilation, allPerms,
+ options.getLocalWorkers(), resultFiles);
+
+ ArtifactSet generatedArtifacts = precompilation.getGeneratedArtifacts();
+ JJSOptions precompileOptions = precompilation.getUnifiedAst().getOptions();
+
+ precompilation = null; // No longer needed, so save the memory
+
+ Link.legacyLink(logger.branch(TreeLogger.TRACE, "Linking into "
+ + options.getOutDir().getPath()), module, generatedArtifacts,
+ allPerms, resultFiles, options.getOutDir(), precompileOptions);
+
+ long compileDone = System.currentTimeMillis();
+ long delta = compileDone - compileStart;
+ if (logger.isLoggable(TreeLogger.INFO)) {
+ logger.log(TreeLogger.INFO, "Compilation succeeded -- "
+ + String.format("%.3f", delta / 1000d) + "s");
+ }
+ }
+ }
+ } catch (IOException e) {
+ logger.log(TreeLogger.ERROR, "Unable to create compiler work directory",
+ e);
+ return false;
+ } finally {
+ compileEvent.end();
+ if (tempWorkDir) {
+ Util.recursiveDelete(options.getWorkDir(), false);
+ }
+ }
+ return true;
+ }
+}
diff --git a/dev/core/src/com/google/gwt/dev/GWTShell.java b/dev/core/src/com/google/gwt/dev/GWTShell.java
new file mode 100644
index 0000000..77339ff
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/GWTShell.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright 2008 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;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.linker.ArtifactSet;
+import com.google.gwt.core.ext.linker.EmittedArtifact.Visibility;
+import com.google.gwt.core.ext.linker.impl.StandardLinkerContext;
+import com.google.gwt.dev.cfg.ModuleDef;
+import com.google.gwt.dev.shell.WorkDirs;
+import com.google.gwt.dev.shell.tomcat.EmbeddedTomcatServer;
+import com.google.gwt.dev.util.OutputFileSetOnDirectory;
+import com.google.gwt.dev.util.arg.ArgHandlerDisableUpdateCheck;
+import com.google.gwt.dev.util.arg.ArgHandlerOutDir;
+import com.google.gwt.util.tools.ArgHandlerExtra;
+
+import java.io.File;
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * The main executable class for the hosted mode shell.
+ */
+@Deprecated
+public class GWTShell extends DevModeBase {
+
+ /**
+ * Handles the list of startup urls that can be passed at the end of the
+ * command line.
+ */
+ protected static class ArgHandlerStartupURLsExtra extends ArgHandlerExtra {
+
+ private final OptionStartupURLs options;
+
+ public ArgHandlerStartupURLsExtra(OptionStartupURLs options) {
+ this.options = options;
+ }
+
+ @Override
+ public boolean addExtraArg(String arg) {
+ options.addStartupURL(arg);
+ return true;
+ }
+
+ @Override
+ public String getPurpose() {
+ return "Automatically launches the specified URL";
+ }
+
+ @Override
+ public String[] getTagArgs() {
+ return new String[] {"url"};
+ }
+ }
+
+ /**
+ * The GWTShell argument processor.
+ */
+ protected static class ArgProcessor extends DevModeBase.ArgProcessor {
+ public ArgProcessor(ShellOptionsImpl options, boolean forceServer,
+ boolean noURLs) {
+ super(options, forceServer);
+ if (!noURLs) {
+ registerHandler(new ArgHandlerStartupURLsExtra(options));
+ }
+ registerHandler(new ArgHandlerOutDir(options));
+ registerHandler(new ArgHandlerDisableUpdateCheck(options));
+ }
+
+ @Override
+ protected String getName() {
+ return GWTShell.class.getName();
+ }
+ }
+
+ /**
+ * Concrete class to implement all shell options.
+ */
+ protected static class ShellOptionsImpl extends HostedModeBaseOptionsImpl
+ implements WorkDirs, LegacyCompilerOptions {
+ private int localWorkers;
+ private File outDir;
+
+ public File getCompilerOutputDir(ModuleDef moduleDef) {
+ return new File(getOutDir(), moduleDef.getName());
+ }
+
+ public int getLocalWorkers() {
+ return localWorkers;
+ }
+
+ public File getOutDir() {
+ return outDir;
+ }
+
+ public File getShellPublicGenDir(ModuleDef moduleDef) {
+ File moduleWorkDir = new File(getWorkDir(), moduleDef.getName());
+ return new File(moduleWorkDir, "public");
+ }
+
+ @Override
+ public File getWorkDir() {
+ return new File(getOutDir(), ".gwt-tmp");
+ }
+
+ public void setLocalWorkers(int localWorkers) {
+ this.localWorkers = localWorkers;
+ }
+
+ public void setOutDir(File outDir) {
+ this.outDir = outDir;
+ }
+ }
+
+ public static String checkHost(String hostUnderConsideration,
+ Set<String> hosts) {
+ hostUnderConsideration = hostUnderConsideration.toLowerCase(Locale.ENGLISH);
+ for (String rule : hosts) {
+ // match on lowercased regex
+ if (hostUnderConsideration.matches(".*" + rule + ".*")) {
+ return rule;
+ }
+ }
+ return null;
+ }
+
+ public static String computeHostRegex(String url) {
+ // the entire URL up to the first slash not prefixed by a slash or colon.
+ String raw = url.split("(?<![:/])/")[0];
+ // escape the dots and put a begin line specifier on the result
+ return "^" + raw.replaceAll("[.]", "[.]");
+ }
+
+ public static String formatRules(Set<String> invalidHttpHosts) {
+ StringBuffer out = new StringBuffer();
+ for (String rule : invalidHttpHosts) {
+ out.append(rule);
+ out.append(" ");
+ }
+ return out.toString();
+ }
+
+ public static void main(String[] args) {
+ /*
+ * NOTE: main always exits with a call to System.exit to terminate any
+ * non-daemon threads that were started in Generators. Typically, this is to
+ * shutdown AWT related threads, since the contract for their termination is
+ * still implementation-dependent.
+ */
+ GWTShell gwtShell = new GWTShell();
+ ArgProcessor argProcessor = new ArgProcessor(gwtShell.options, false, false);
+ if (argProcessor.processArgs(args)) {
+ gwtShell.run();
+ // Exit w/ success code.
+ System.exit(0);
+ }
+ // Exit w/ non-success code.
+ System.exit(-1);
+ }
+
+ /**
+ * Hiding super field because it's actually the same object, just with a
+ * stronger type.
+ */
+ @SuppressWarnings("hiding")
+ protected final ShellOptionsImpl options = (ShellOptionsImpl) super.options;
+
+ protected File outDir;
+
+ @SuppressWarnings("unused")
+ public void restartServer(TreeLogger logger) throws UnableToCompleteException {
+ // Unimplemented.
+ }
+
+ @Override
+ protected HostedModeBaseOptions createOptions() {
+ return new ShellOptionsImpl();
+ }
+
+ @Override
+ protected void doShutDownServer() {
+ // Stop the HTTP server.
+ //
+ EmbeddedTomcatServer.stop();
+ }
+
+ @Override
+ protected boolean doStartup() {
+ File persistentCacheDir = new File(options.getWorkDir(), "gwt-unitCache");
+ return super.doStartup(persistentCacheDir);
+ }
+
+ @Override
+ protected int doStartUpServer() {
+ // TODO(jat): find a safe way to get an icon for Tomcat
+ TreeLogger logger = ui.getWebServerLogger("Tomcat", null);
+ // TODO(bruce): make tomcat work in terms of the modular launcher
+ String whyFailed = EmbeddedTomcatServer.start(isHeadless() ? getTopLogger()
+ : logger, getPort(), options, shouldAutoGenerateResources());
+
+ if (whyFailed != null) {
+ getTopLogger().log(TreeLogger.ERROR, "Starting Tomcat: " + whyFailed);
+ return -1;
+ }
+ return EmbeddedTomcatServer.getPort();
+ }
+
+ @Override
+ protected synchronized void produceOutput(TreeLogger logger,
+ StandardLinkerContext linkerStack, ArtifactSet artifacts,
+ ModuleDef module, boolean isRelink) throws UnableToCompleteException {
+ /*
+ * Legacy: in GWTShell we only copy generated artifacts into the public gen
+ * folder. Public files and "autogen" files have special handling (that
+ * needs to die).
+ */
+ if (isRelink) {
+ File outputDir = options.getShellPublicGenDir(module);
+ outputDir.mkdirs();
+ OutputFileSetOnDirectory outFileSet = new OutputFileSetOnDirectory(
+ outputDir, "");
+ linkerStack.produceOutput(logger, artifacts, Visibility.Public,
+ outFileSet);
+ outFileSet.close();
+ }
+ }
+
+ protected boolean shouldAutoGenerateResources() {
+ return true;
+ }
+
+ @Override
+ protected void warnAboutNoStartupUrls() {
+ getTopLogger().log(TreeLogger.WARN,
+ "No startup URLs were supplied -- add them to the end of the GWTShell"
+ + " command line");
+ }
+}
diff --git a/dev/core/src/com/google/gwt/dev/cfg/ModuleDef.java b/dev/core/src/com/google/gwt/dev/cfg/ModuleDef.java
index 378ab1a..8d972e9 100644
--- a/dev/core/src/com/google/gwt/dev/cfg/ModuleDef.java
+++ b/dev/core/src/com/google/gwt/dev/cfg/ModuleDef.java
@@ -466,9 +466,9 @@
}
/**
- * For convenience in unit tests, servlets can be automatically loaded and
- * mapped in the embedded web server. If a servlet is already mapped to the
- * specified path, it is replaced.
+ * For convenience in hosted mode, servlets can be automatically loaded and
+ * delegated to via {@link com.google.gwt.dev.shell.GWTShellServlet}. If a
+ * servlet is already mapped to the specified path, it is replaced.
*
* @param path the url path at which the servlet resides
* @param servletClassName the name of the servlet to publish
diff --git a/dev/core/src/com/google/gwt/dev/etc/tomcat/conf/web.xml b/dev/core/src/com/google/gwt/dev/etc/tomcat/conf/web.xml
new file mode 100644
index 0000000..fee85f3
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/etc/tomcat/conf/web.xml
@@ -0,0 +1,566 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!-- A tweaked version of the default Tomcat web.xml to remove everything except the stuff we want to use -->
+<web-app version="2.4">
+
+ <session-config>
+ <session-timeout>30</session-timeout>
+ </session-config>
+
+ <mime-mapping>
+ <extension>abs</extension>
+ <mime-type>audio/x-mpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>ai</extension>
+ <mime-type>application/postscript</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>aif</extension>
+ <mime-type>audio/x-aiff</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>aifc</extension>
+ <mime-type>audio/x-aiff</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>aiff</extension>
+ <mime-type>audio/x-aiff</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>aim</extension>
+ <mime-type>application/x-aim</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>art</extension>
+ <mime-type>image/x-jg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>asf</extension>
+ <mime-type>video/x-ms-asf</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>asx</extension>
+ <mime-type>video/x-ms-asf</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>au</extension>
+ <mime-type>audio/basic</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>avi</extension>
+ <mime-type>video/x-msvideo</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>avx</extension>
+ <mime-type>video/x-rad-screenplay</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>bcpio</extension>
+ <mime-type>application/x-bcpio</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>bin</extension>
+ <mime-type>application/octet-stream</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>bmp</extension>
+ <mime-type>image/bmp</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>body</extension>
+ <mime-type>text/html</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>cdf</extension>
+ <mime-type>application/x-cdf</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>cer</extension>
+ <mime-type>application/x-x509-ca-cert</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>class</extension>
+ <mime-type>application/java</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>cpio</extension>
+ <mime-type>application/x-cpio</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>csh</extension>
+ <mime-type>application/x-csh</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>css</extension>
+ <mime-type>text/css</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>dib</extension>
+ <mime-type>image/bmp</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>doc</extension>
+ <mime-type>application/msword</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>dtd</extension>
+ <mime-type>text/plain</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>dv</extension>
+ <mime-type>video/x-dv</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>dvi</extension>
+ <mime-type>application/x-dvi</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>eps</extension>
+ <mime-type>application/postscript</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>etx</extension>
+ <mime-type>text/x-setext</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>exe</extension>
+ <mime-type>application/octet-stream</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>gif</extension>
+ <mime-type>image/gif</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>gtar</extension>
+ <mime-type>application/x-gtar</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>gz</extension>
+ <mime-type>application/x-gzip</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>hdf</extension>
+ <mime-type>application/x-hdf</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>hqx</extension>
+ <mime-type>application/mac-binhex40</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>htc</extension>
+ <mime-type>text/x-component</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>htm</extension>
+ <mime-type>text/html</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>html</extension>
+ <mime-type>text/html</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>hqx</extension>
+ <mime-type>application/mac-binhex40</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>ief</extension>
+ <mime-type>image/ief</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>jad</extension>
+ <mime-type>text/vnd.sun.j2me.app-descriptor</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>jar</extension>
+ <mime-type>application/java-archive</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>java</extension>
+ <mime-type>text/plain</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>jnlp</extension>
+ <mime-type>application/x-java-jnlp-file</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>jpe</extension>
+ <mime-type>image/jpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>jpeg</extension>
+ <mime-type>image/jpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>jpg</extension>
+ <mime-type>image/jpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>js</extension>
+ <mime-type>text/javascript</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>jsf</extension>
+ <mime-type>text/plain</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>jspf</extension>
+ <mime-type>text/plain</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>kar</extension>
+ <mime-type>audio/x-midi</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>latex</extension>
+ <mime-type>application/x-latex</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>m3u</extension>
+ <mime-type>audio/x-mpegurl</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mac</extension>
+ <mime-type>image/x-macpaint</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>man</extension>
+ <mime-type>application/x-troff-man</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>me</extension>
+ <mime-type>application/x-troff-me</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mid</extension>
+ <mime-type>audio/x-midi</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>midi</extension>
+ <mime-type>audio/x-midi</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mif</extension>
+ <mime-type>application/x-mif</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mov</extension>
+ <mime-type>video/quicktime</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>movie</extension>
+ <mime-type>video/x-sgi-movie</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mp1</extension>
+ <mime-type>audio/x-mpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mp2</extension>
+ <mime-type>audio/x-mpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mp3</extension>
+ <mime-type>audio/x-mpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mpa</extension>
+ <mime-type>audio/x-mpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mpe</extension>
+ <mime-type>video/mpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mpeg</extension>
+ <mime-type>video/mpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mpega</extension>
+ <mime-type>audio/x-mpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mpg</extension>
+ <mime-type>video/mpeg</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>mpv2</extension>
+ <mime-type>video/mpeg2</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>ms</extension>
+ <mime-type>application/x-wais-source</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>nc</extension>
+ <mime-type>application/x-netcdf</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>oda</extension>
+ <mime-type>application/oda</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>pbm</extension>
+ <mime-type>image/x-portable-bitmap</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>pct</extension>
+ <mime-type>image/pict</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>pdf</extension>
+ <mime-type>application/pdf</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>pgm</extension>
+ <mime-type>image/x-portable-graymap</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>pic</extension>
+ <mime-type>image/pict</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>pict</extension>
+ <mime-type>image/pict</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>pls</extension>
+ <mime-type>audio/x-scpls</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>png</extension>
+ <mime-type>image/png</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>pnm</extension>
+ <mime-type>image/x-portable-anymap</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>pnt</extension>
+ <mime-type>image/x-macpaint</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>ppm</extension>
+ <mime-type>image/x-portable-pixmap</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>ppt</extension>
+ <mime-type>application/powerpoint</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>ps</extension>
+ <mime-type>application/postscript</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>psd</extension>
+ <mime-type>image/x-photoshop</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>qt</extension>
+ <mime-type>video/quicktime</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>qti</extension>
+ <mime-type>image/x-quicktime</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>qtif</extension>
+ <mime-type>image/x-quicktime</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>ras</extension>
+ <mime-type>image/x-cmu-raster</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>rgb</extension>
+ <mime-type>image/x-rgb</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>rm</extension>
+ <mime-type>application/vnd.rn-realmedia</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>roff</extension>
+ <mime-type>application/x-troff</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>rtf</extension>
+ <mime-type>application/rtf</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>rtx</extension>
+ <mime-type>text/richtext</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>sh</extension>
+ <mime-type>application/x-sh</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>shar</extension>
+ <mime-type>application/x-shar</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>smf</extension>
+ <mime-type>audio/x-midi</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>sit</extension>
+ <mime-type>application/x-stuffit</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>snd</extension>
+ <mime-type>audio/basic</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>src</extension>
+ <mime-type>application/x-wais-source</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>sv4cpio</extension>
+ <mime-type>application/x-sv4cpio</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>sv4crc</extension>
+ <mime-type>application/x-sv4crc</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>swf</extension>
+ <mime-type>application/x-shockwave-flash</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>t</extension>
+ <mime-type>application/x-troff</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>tar</extension>
+ <mime-type>application/x-tar</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>tcl</extension>
+ <mime-type>application/x-tcl</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>tex</extension>
+ <mime-type>application/x-tex</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>texi</extension>
+ <mime-type>application/x-texinfo</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>texinfo</extension>
+ <mime-type>application/x-texinfo</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>tif</extension>
+ <mime-type>image/tiff</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>tiff</extension>
+ <mime-type>image/tiff</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>tr</extension>
+ <mime-type>application/x-troff</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>tsv</extension>
+ <mime-type>text/tab-separated-values</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>txt</extension>
+ <mime-type>text/plain</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>ulw</extension>
+ <mime-type>audio/basic</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>ustar</extension>
+ <mime-type>application/x-ustar</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>xbm</extension>
+ <mime-type>image/x-xbitmap</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>xht</extension>
+ <mime-type>application/xhtml+xml</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>xhtml</extension>
+ <mime-type>application/xhtml+xml</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>xml</extension>
+ <mime-type>text/xml</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>xpm</extension>
+ <mime-type>image/x-xpixmap</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>xsl</extension>
+ <mime-type>text/xml</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>xwd</extension>
+ <mime-type>image/x-xwindowdump</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>wav</extension>
+ <mime-type>audio/x-wav</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>svg</extension>
+ <mime-type>image/svg+xml</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>svgz</extension>
+ <mime-type>image/svg+xml</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>vsd</extension>
+ <mime-type>application/x-visio</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <!-- Wireless Bitmap -->
+ <extension>wbmp</extension>
+ <mime-type>image/vnd.wap.wbmp</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <!-- WML Source -->
+ <extension>wml</extension>
+ <mime-type>text/vnd.wap.wml</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <!-- Compiled WML -->
+ <extension>wmlc</extension>
+ <mime-type>application/vnd.wap.wmlc</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <!-- WML Script Source -->
+ <extension>wmls</extension>
+ <mime-type>text/vnd.wap.wmlscript</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <!-- Compiled WML Script -->
+ <extension>wmlscriptc</extension>
+ <mime-type>application/vnd.wap.wmlscriptc</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>wrl</extension>
+ <mime-type>x-world/x-vrml</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>Z</extension>
+ <mime-type>application/x-compress</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>z</extension>
+ <mime-type>application/x-compress</mime-type>
+ </mime-mapping>
+ <mime-mapping>
+ <extension>zip</extension>
+ <mime-type>application/zip</mime-type>
+ </mime-mapping>
+</web-app>
diff --git a/dev/core/src/com/google/gwt/dev/etc/tomcat/webapps/ROOT/WEB-INF/web.xml b/dev/core/src/com/google/gwt/dev/etc/tomcat/webapps/ROOT/WEB-INF/web.xml
new file mode 100644
index 0000000..e600b2f
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/etc/tomcat/webapps/ROOT/WEB-INF/web.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app>
+
+ <servlet>
+ <servlet-name>shell</servlet-name>
+ <servlet-class>com.google.gwt.dev.shell.GWTShellServlet</servlet-class>
+ </servlet>
+
+ <servlet-mapping>
+ <servlet-name>shell</servlet-name>
+ <url-pattern>/*</url-pattern>
+ </servlet-mapping>
+
+</web-app>
diff --git a/dev/core/src/com/google/gwt/dev/shell/GWTShellServlet.java b/dev/core/src/com/google/gwt/dev/shell/GWTShellServlet.java
new file mode 100644
index 0000000..9e7ead7
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/shell/GWTShellServlet.java
@@ -0,0 +1,991 @@
+/*
+ * Copyright 2008 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;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.linker.ArtifactSet;
+import com.google.gwt.core.ext.linker.impl.HostedModeLinker;
+import com.google.gwt.core.ext.linker.impl.StandardLinkerContext;
+import com.google.gwt.dev.cfg.ModuleDef;
+import com.google.gwt.dev.cfg.ModuleDefLoader;
+import com.google.gwt.dev.jjs.JJSOptionsImpl;
+import com.google.gwt.dev.resource.Resource;
+import com.google.gwt.dev.shell.log.ServletContextTreeLogger;
+import com.google.gwt.dev.util.HttpHeaders;
+import com.google.gwt.dev.util.Util;
+import com.google.gwt.thirdparty.guava.common.collect.MapMaker;
+import com.google.gwt.util.tools.Utility;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * Built-in servlet for convenient access to the public path of a specified
+ * module.
+ */
+public class GWTShellServlet extends HttpServlet {
+
+ private static class RequestParts {
+ public final String moduleName;
+
+ public final String partialPath;
+
+ public RequestParts(HttpServletRequest request)
+ throws UnableToCompleteException {
+ String pathInfo = request.getPathInfo();
+ if (pathInfo != null) {
+ int slash = pathInfo.indexOf('/', 1);
+ if (slash != -1) {
+ moduleName = pathInfo.substring(1, slash);
+ partialPath = pathInfo.substring(slash + 1);
+ return;
+ } else {
+ moduleName = pathInfo.substring(1);
+ partialPath = null;
+ return;
+ }
+ }
+ throw new UnableToCompleteException();
+ }
+ }
+
+ /**
+ * This the default cache time in seconds for files that aren't either
+ * *.cache.*, *.nocache.*.
+ */
+ private static final int DEFAULT_CACHE_SECONDS = 5;
+
+ private static final String XHTML_MIME_TYPE = "application/xhtml+xml";
+
+ /**
+ * Must keep only weak references to ModuleDefs else we permanently pin them.
+ */
+ private final Map<String, ModuleDef> loadedModulesByName = new MapMaker().weakValues().makeMap();
+
+ /**
+ * The lifetime of the module pins the lifetime of the associated servlet;
+ * this is because the loaded servlet has a weak backRef to its live module
+ * through its context. When the module dies, the servlet needs to die also.
+ */
+ private final Map<ModuleDef, Map<String, HttpServlet>> loadedServletsByModuleAndClassName =
+ new MapMaker().weakKeys().makeMap();
+
+ private final Map<String, String> mimeTypes = new HashMap<String, String>();
+
+ /**
+ * Only for backwards compatibility. Shouldn't we remove this now?
+ */
+ private final Map<String, ModuleDef> modulesByServletPath = new MapMaker().weakValues().makeMap();
+
+ private int nextRequestId;
+
+ private final Object requestIdLock = new Object();
+
+ private TreeLogger topLogger;
+
+ private WorkDirs workDirs;
+
+ public GWTShellServlet() {
+ initMimeTypes();
+ }
+
+ @Override
+ protected void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ processFileRequest(request, response);
+ }
+
+ @Override
+ protected void doPost(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ processFileRequest(request, response);
+ }
+
+ protected void processFileRequest(HttpServletRequest request,
+ HttpServletResponse response) throws IOException {
+
+ String pathInfo = request.getPathInfo();
+ if (pathInfo.length() == 0 || pathInfo.equals("/")) {
+ response.setContentType("text/html");
+ PrintWriter writer = response.getWriter();
+ writer.println("<html><body><basefont face='arial'>");
+ writer.println("To launch an application, specify a URL of the form <code>/<i>module</i>/<i>file.html</i></code>");
+ writer.println("</body></html>");
+ return;
+ }
+
+ TreeLogger logger = getLogger();
+
+ // Parse the request assuming it is module/resource.
+ //
+ RequestParts parts;
+ try {
+ parts = new RequestParts(request);
+ } catch (UnableToCompleteException e) {
+ sendErrorResponse(response, HttpServletResponse.SC_NOT_FOUND,
+ "Don't know what to do with this URL: '" + pathInfo + "'");
+ return;
+ }
+
+ String partialPath = parts.partialPath;
+ String moduleName = parts.moduleName;
+
+ // If the module is renamed, substitute the renamed module name
+ ModuleDef moduleDef = loadedModulesByName.get(moduleName);
+ if (moduleDef != null) {
+ moduleName = moduleDef.getName();
+ }
+
+ if (partialPath == null) {
+ // Redir back to the same URL but ending with a slash.
+ //
+ response.sendRedirect(moduleName + "/");
+ return;
+ } else if (partialPath.length() > 0) {
+ // Both the module name and a resource.
+ //
+ doGetPublicFile(request, response, logger, partialPath, moduleName);
+ return;
+ } else {
+ // Was just the module name, ending with a slash.
+ //
+ doGetModule(request, response, logger, parts);
+ return;
+ }
+ }
+
+ @Override
+ protected void service(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ TreeLogger logger = getLogger();
+ int id = allocateRequestId();
+ if (logger.isLoggable(TreeLogger.TRACE)) {
+ StringBuffer url = request.getRequestURL();
+
+ // Branch the logger in case we decide to log more below.
+ logger = logger.branch(TreeLogger.TRACE, "Request " + id + ": " + url,
+ null);
+ }
+
+ String servletClassName = null;
+ ModuleDef moduleDef = null;
+
+ try {
+ // Attempt to split the URL into module/path, which we'll use to see
+ // if we can map the request to a module's servlet.
+ RequestParts parts = new RequestParts(request);
+
+ if ("favicon.ico".equalsIgnoreCase(parts.moduleName)) {
+ sendErrorResponse(response, HttpServletResponse.SC_NOT_FOUND,
+ "Icon not available");
+ return;
+ }
+
+ // See if the request references a module we know.
+ moduleDef = getModuleDef(logger, parts.moduleName);
+ if (moduleDef != null) {
+ // Okay, we know this module. Do we know this servlet path?
+ // It is right to prepend the slash because (1) ModuleDefSchema requires
+ // every servlet path to begin with a slash and (2) RequestParts always
+ // rips off the leading slash.
+ String servletPath = "/" + parts.partialPath;
+ servletClassName = moduleDef.findServletForPath(servletPath);
+
+ // Fall-through below, where we check servletClassName.
+ } else {
+ // Fall-through below, where we check servletClassName.
+ }
+ } catch (UnableToCompleteException e) {
+ // Do nothing, since it was speculative anyway.
+ }
+
+ // BEGIN BACKWARD COMPATIBILITY
+ if (servletClassName == null) {
+ // Try to map a bare path that isn't preceded by the module name.
+ // This is no longer the recommended practice, so we warn.
+ String path = request.getPathInfo();
+ moduleDef = modulesByServletPath.get(path);
+ if (moduleDef != null) {
+ // See if there is a servlet we can delegate to for the given url.
+ servletClassName = moduleDef.findServletForPath(path);
+
+ if (servletClassName != null) {
+ TreeLogger branch = logger.branch(TreeLogger.WARN,
+ "Use of deprecated hosted mode servlet path mapping", null);
+ branch.log(
+ TreeLogger.WARN,
+ "The client code is invoking the servlet with a URL that is not module-relative: "
+ + path, null);
+ branch.log(
+ TreeLogger.WARN,
+ "Prepend GWT.getModuleBaseURL() to the URL in client code to create a module-relative URL: /"
+ + moduleDef.getName() + path, null);
+ branch.log(
+ TreeLogger.WARN,
+ "Using module-relative URLs ensures correct URL-independent behavior in external servlet containers",
+ null);
+ }
+
+ // Fall-through below, where we check servletClassName.
+ } else {
+ // Fall-through below, where we check servletClassName.
+ }
+ }
+ // END BACKWARD COMPATIBILITY
+
+ // Load/get the servlet if we found one.
+ if (servletClassName != null) {
+ HttpServlet delegatee = tryGetOrLoadServlet(logger, moduleDef,
+ servletClassName);
+ if (delegatee == null) {
+ logger.log(TreeLogger.ERROR, "Unable to dispatch request", null);
+ sendErrorResponse(response,
+ HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
+ "Unable to find/load mapped servlet class '" + servletClassName
+ + "'");
+ return;
+ }
+
+ // Delegate everything to the downstream servlet and we're done.
+ delegatee.service(request, response);
+ } else {
+ // Use normal default processing on this request, since we couldn't
+ // recognize it as anything special.
+ super.service(request, response);
+ }
+ }
+
+ private int allocateRequestId() {
+ synchronized (requestIdLock) {
+ return nextRequestId++;
+ }
+ }
+
+ /**
+ * Handle auto-generated resources.
+ *
+ * @return <code>true</code> if a resource was generated
+ */
+ private boolean autoGenerateResources(HttpServletRequest request,
+ HttpServletResponse response, TreeLogger logger, String partialPath,
+ String moduleName) throws IOException {
+
+ if (partialPath.equals(moduleName + ".nocache.js")) {
+ if (request.getParameter("compiled") == null) {
+ // Generate the .js file.
+ try {
+ String js = genSelectionScript(logger, moduleName);
+ setResponseCacheHeaders(response, 0); // do not cache selection script
+ response.setStatus(HttpServletResponse.SC_OK);
+ response.setContentType("text/javascript");
+ response.getWriter().println(js);
+ return true;
+ } catch (UnableToCompleteException e) {
+ // The error will have already been logged. Continue, since this could
+ // actually be a request for a static file that happens to have an
+ // unfortunately confusing name.
+ }
+ }
+ } else if (partialPath.equals("hosted.html")) {
+ String html = HostedModeLinker.getHostedHtml();
+ setResponseCacheHeaders(response, DEFAULT_CACHE_SECONDS);
+ response.setStatus(HttpServletResponse.SC_OK);
+ response.setContentType("text/html");
+ response.getWriter().println(html);
+ return true;
+ }
+
+ return false;
+ }
+
+ private void doGetModule(HttpServletRequest request,
+ HttpServletResponse response, TreeLogger logger, RequestParts parts)
+ throws IOException {
+
+ // Generate a generic empty host page.
+ //
+ String msg = "The development shell servlet received a request to generate a host page for module '"
+ + parts.moduleName + "' ";
+
+ logger = logger.branch(TreeLogger.TRACE, msg, null);
+
+ try {
+ // Try to load the module just to make sure it'll work.
+ getModuleDef(logger, parts.moduleName);
+ } catch (UnableToCompleteException e) {
+ sendErrorResponse(response, HttpServletResponse.SC_NOT_FOUND,
+ "Unable to find/load module '" + Util.escapeXml(parts.moduleName)
+ + "' (see server log for details)");
+ return;
+ }
+
+ response.setContentType("text/html");
+ PrintWriter writer = response.getWriter();
+ writer.println("<html><head>");
+ writer.print("<script language='javascript' src='");
+ writer.print(parts.moduleName);
+ writer.println(".nocache.js'></script>");
+
+ // Create a property for each query param.
+ Map<String, String[]> params = getParameterMap(request);
+ for (Map.Entry<String, String[]> entry : params.entrySet()) {
+ String[] values = entry.getValue();
+ if (values.length > 0) {
+ writer.print("<meta name='gwt:property' content='");
+ writer.print(entry.getKey());
+ writer.print("=");
+ writer.print(values[values.length - 1]);
+ writer.println("'>");
+ }
+ }
+
+ writer.println("</head><body>");
+ writer.println("<iframe src=\"javascript:''\" id='__gwt_historyFrame' "
+ + "style='position:absolute;width:0;height:0;border:0'></iframe>");
+ writer.println("<noscript>");
+ writer.println(" <div style=\"width: 22em; position: absolute; left: 50%; margin-left: -11em; color: red; background-color: white; border: 1px solid red; padding: 4px; font-family: sans-serif\">");
+ writer.println(" Your web browser must have JavaScript enabled");
+ writer.println(" in order for this application to display correctly.");
+ writer.println(" </div>");
+ writer.println("</noscript>");
+ writer.println("</body></html>");
+
+ // Done.
+ }
+
+ /**
+ * Fetch a file and return it as the HTTP response, setting the cache-related
+ * headers according to the name of the file (see
+ * {@link #getCacheTime(String)}). This function honors If-Modified-Since to
+ * minimize the impact of limiting caching of files for development.
+ *
+ * @param request the HTTP request
+ * @param response the HTTP response
+ * @param logger a TreeLogger to use for debug output
+ * @param partialPath the path within the module
+ * @param moduleName the name of the module
+ * @throws IOException
+ */
+ @SuppressWarnings("deprecation")
+ private void doGetPublicFile(HttpServletRequest request,
+ HttpServletResponse response, TreeLogger logger, String partialPath,
+ String moduleName) throws IOException {
+
+ // Create a logger branch for this request.
+ logger = logger.branch(TreeLogger.TRACE,
+ "The development shell servlet received a request for '"
+ + partialPath + "' in module '" + moduleName + ".gwt.xml' ", null);
+
+ // Handle auto-generation of resources.
+ if (shouldAutoGenerateResources()) {
+ if (autoGenerateResources(request, response, logger, partialPath,
+ moduleName)) {
+ return;
+ }
+ }
+
+ URL foundResource = null;
+ try {
+ // Look for the requested file on the public path.
+ //
+ ModuleDef moduleDef = getModuleDef(logger, moduleName);
+ if (shouldAutoGenerateResources()) {
+ Resource publicResource = moduleDef.findPublicFile(partialPath);
+ if (publicResource != null) {
+ foundResource = publicResource.getURL();
+ }
+
+ if (foundResource == null) {
+ // Look for public generated files
+ File shellDir = getShellWorkDirs().getShellPublicGenDir(moduleDef);
+ File requestedFile = new File(shellDir, partialPath);
+ if (requestedFile.exists()) {
+ try {
+ foundResource = requestedFile.toURI().toURL();
+ } catch (MalformedURLException e) {
+ // ignore since it was speculative anyway
+ }
+ }
+ }
+ }
+
+ /*
+ * If the user is coming from compiled web-mode, check the linker output
+ * directory for the real bootstrap file.
+ */
+ if (foundResource == null) {
+ File moduleDir = getShellWorkDirs().getCompilerOutputDir(moduleDef);
+ File requestedFile = new File(moduleDir, partialPath);
+ if (requestedFile.exists()) {
+ try {
+ foundResource = requestedFile.toURI().toURL();
+ } catch (MalformedURLException e) {
+ // ignore since it was speculative anyway
+ }
+ }
+ }
+
+ if (foundResource == null) {
+ String msg;
+ if ("gwt.js".equals(partialPath)) {
+ msg = "Loading the old 'gwt.js' bootstrap script is no longer supported; please load '"
+ + moduleName + ".nocache.js' directly";
+ } else {
+ msg = "Resource not found: " + partialPath + "; "
+ + "(could a file be missing from the public path or a <servlet> "
+ + "tag misconfigured in module " + moduleName + ".gwt.xml ?)";
+ }
+ logger.log(TreeLogger.WARN, msg, null);
+ throw new UnableToCompleteException();
+ }
+ } catch (UnableToCompleteException e) {
+ sendErrorResponse(response, HttpServletResponse.SC_NOT_FOUND,
+ "Cannot find resource '" + partialPath
+ + "' in the public path of module '" + moduleName + "'");
+ return;
+ }
+
+ // Get the MIME type.
+ String path = foundResource.toExternalForm();
+ String mimeType = null;
+ try {
+ mimeType = getServletContext().getMimeType(path);
+ } catch (UnsupportedOperationException e) {
+ // Certain minimalist servlet containers throw this.
+ // Fall through to guess the type.
+ }
+
+ if (mimeType == null) {
+ mimeType = guessMimeType(path);
+ if (logger.isLoggable(TreeLogger.TRACE)) {
+ logger.log(TreeLogger.TRACE, "Guessed MIME type '" + mimeType + "'", null);
+ }
+ }
+
+ maybeIssueXhtmlWarning(logger, mimeType, partialPath);
+
+ long cacheSeconds = getCacheTime(path);
+
+ InputStream is = null;
+ try {
+ // Check for up-to-datedness.
+ URLConnection conn = foundResource.openConnection();
+ long lastModified = conn.getLastModified();
+ if (isNotModified(request, lastModified)) {
+ response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
+ setResponseCacheHeaders(response, cacheSeconds);
+ return;
+ }
+
+ // Set up headers to really send it.
+ response.setStatus(HttpServletResponse.SC_OK);
+ long now = new Date().getTime();
+ response.setHeader(HttpHeaders.DATE,
+ HttpHeaders.toInternetDateFormat(now));
+ response.setContentType(mimeType);
+ String lastModifiedStr = HttpHeaders.toInternetDateFormat(lastModified);
+ response.setHeader(HttpHeaders.LAST_MODIFIED, lastModifiedStr);
+
+ // Expiration header. Either immediately stale (requiring an
+ // "If-Modified-Since") or infinitely cacheable (not requiring even a
+ // freshness check).
+ setResponseCacheHeaders(response, cacheSeconds);
+
+ // Content length.
+ int contentLength = conn.getContentLength();
+ if (contentLength >= 0) {
+ response.setHeader(HttpHeaders.CONTENT_LENGTH,
+ Integer.toString(contentLength));
+ }
+
+ // Send the bytes.
+ is = conn.getInputStream();
+ streamOut(is, response.getOutputStream(), 1024 * 8);
+ } finally {
+ Utility.close(is);
+ }
+ }
+
+ /**
+ * Generates a module.js file on the fly. Note that the nocache file that is
+ * generated that can only be used for hosted mode. It cannot produce a web
+ * mode version, since this servlet doesn't know strong names, since by
+ * definition of "hosted mode" JavaScript hasn't been compiled at this point.
+ */
+ private String genSelectionScript(TreeLogger logger, String moduleName)
+ throws UnableToCompleteException {
+ if (logger.isLoggable(TreeLogger.TRACE)) {
+ logger.log(TreeLogger.TRACE,
+ "Generating a script selection script for module " + moduleName);
+ }
+ ModuleDef module = getModuleDef(logger, moduleName);
+ StandardLinkerContext context = new StandardLinkerContext(logger, module,
+ new JJSOptionsImpl());
+ ArtifactSet artifacts = context.getArtifactsForPublicResources(logger,
+ module);
+ HostedModeLinker linker = new HostedModeLinker();
+ return linker.generateSelectionScript(logger, context, artifacts);
+ }
+
+ /**
+ * Get the length of time a given file should be cacheable. If the path
+ * contains *.nocache.*, it is never cacheable; if it contains *.cache.*, it
+ * is infinitely cacheable; anything else gets a default time.
+ *
+ * @return cache time in seconds, or 0 if the file is not cacheable at all
+ */
+ private long getCacheTime(String path) {
+ int lastDot = path.lastIndexOf('.');
+ if (lastDot >= 0) {
+ String prefix = path.substring(0, lastDot);
+ if (prefix.endsWith(".cache")) {
+ // RFC2616 says to never give a cache time of more than a year
+ // http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.21
+ return HttpHeaders.SEC_YR;
+ } else if (prefix.endsWith(".nocache")) {
+ return 0;
+ }
+ }
+ return DEFAULT_CACHE_SECONDS;
+ }
+
+ private synchronized TreeLogger getLogger() {
+ if (topLogger == null) {
+ ServletContext servletContext = getServletContext();
+ final String attr = "com.google.gwt.dev.shell.logger";
+ topLogger = (TreeLogger) servletContext.getAttribute(attr);
+ if (topLogger == null) {
+ // No shell available, so wrap the regular servlet context logger.
+ //
+ topLogger = new ServletContextTreeLogger(servletContext);
+ }
+ }
+ return topLogger;
+ }
+
+ /**
+ * We don't actually log this on purpose since the client does anyway.
+ */
+ private ModuleDef getModuleDef(TreeLogger logger, String moduleName)
+ throws UnableToCompleteException {
+ synchronized (loadedModulesByName) {
+ ModuleDef moduleDef = loadedModulesByName.get(moduleName);
+ if (moduleDef == null) {
+ moduleDef = ModuleDefLoader.loadFromClassPath(logger, moduleName, false);
+ loadedModulesByName.put(moduleName, moduleDef);
+ loadedModulesByName.put(moduleDef.getName(), moduleDef);
+
+ // BEGIN BACKWARD COMPATIBILITY
+ // The following map of servlet path to module is included only
+ // for backward-compatibility. We are going to remove this functionality
+ // when we go out of beta. The new behavior is that the client should
+ // specify the module name as part of the URL and construct it using
+ // getModuleBaseURL().
+ String[] servletPaths = moduleDef.getServletPaths();
+ for (int i = 0; i < servletPaths.length; i++) {
+ modulesByServletPath.put(servletPaths[i], moduleDef);
+ }
+ // END BACKWARD COMPATIBILITY
+ }
+ return moduleDef;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private Map<String, String[]> getParameterMap(HttpServletRequest request) {
+ return request.getParameterMap();
+ }
+
+ private synchronized WorkDirs getShellWorkDirs() {
+ if (workDirs == null) {
+ ServletContext servletContext = getServletContext();
+ final String attr = "com.google.gwt.dev.shell.workdirs";
+ workDirs = (WorkDirs) servletContext.getAttribute(attr);
+ assert (workDirs != null);
+ }
+ return workDirs;
+ }
+
+ private String guessMimeType(String fullPath) {
+ int dot = fullPath.lastIndexOf('.');
+ if (dot != -1) {
+ String ext = fullPath.substring(dot + 1);
+ String mimeType = mimeTypes.get(ext);
+ if (mimeType != null) {
+ return mimeType;
+ }
+
+ // Otherwise, fall through.
+ //
+ }
+
+ // Last resort.
+ //
+ return "application/octet-stream";
+ }
+
+ private void initMimeTypes() {
+ mimeTypes.put("abs", "audio/x-mpeg");
+ mimeTypes.put("ai", "application/postscript");
+ mimeTypes.put("aif", "audio/x-aiff");
+ mimeTypes.put("aifc", "audio/x-aiff");
+ mimeTypes.put("aiff", "audio/x-aiff");
+ mimeTypes.put("aim", "application/x-aim");
+ mimeTypes.put("art", "image/x-jg");
+ mimeTypes.put("asf", "video/x-ms-asf");
+ mimeTypes.put("asx", "video/x-ms-asf");
+ mimeTypes.put("au", "audio/basic");
+ mimeTypes.put("avi", "video/x-msvideo");
+ mimeTypes.put("avx", "video/x-rad-screenplay");
+ mimeTypes.put("bcpio", "application/x-bcpio");
+ mimeTypes.put("bin", "application/octet-stream");
+ mimeTypes.put("bmp", "image/bmp");
+ mimeTypes.put("body", "text/html");
+ mimeTypes.put("cdf", "application/x-cdf");
+ mimeTypes.put("cer", "application/x-x509-ca-cert");
+ mimeTypes.put("class", "application/java");
+ mimeTypes.put("cpio", "application/x-cpio");
+ mimeTypes.put("csh", "application/x-csh");
+ mimeTypes.put("css", "text/css");
+ mimeTypes.put("dib", "image/bmp");
+ mimeTypes.put("doc", "application/msword");
+ mimeTypes.put("dtd", "text/plain");
+ mimeTypes.put("dv", "video/x-dv");
+ mimeTypes.put("dvi", "application/x-dvi");
+ mimeTypes.put("eps", "application/postscript");
+ mimeTypes.put("etx", "text/x-setext");
+ mimeTypes.put("exe", "application/octet-stream");
+ mimeTypes.put("gif", "image/gif");
+ mimeTypes.put("gtar", "application/x-gtar");
+ mimeTypes.put("gz", "application/x-gzip");
+ mimeTypes.put("hdf", "application/x-hdf");
+ mimeTypes.put("hqx", "application/mac-binhex40");
+ mimeTypes.put("htc", "text/x-component");
+ mimeTypes.put("htm", "text/html");
+ mimeTypes.put("html", "text/html");
+ mimeTypes.put("hqx", "application/mac-binhex40");
+ mimeTypes.put("ief", "image/ief");
+ mimeTypes.put("jad", "text/vnd.sun.j2me.app-descriptor");
+ mimeTypes.put("jar", "application/java-archive");
+ mimeTypes.put("java", "text/plain");
+ mimeTypes.put("jnlp", "application/x-java-jnlp-file");
+ mimeTypes.put("jpe", "image/jpeg");
+ mimeTypes.put("jpeg", "image/jpeg");
+ mimeTypes.put("jpg", "image/jpeg");
+ mimeTypes.put("js", "text/javascript");
+ mimeTypes.put("jsf", "text/plain");
+ mimeTypes.put("jspf", "text/plain");
+ mimeTypes.put("kar", "audio/x-midi");
+ mimeTypes.put("latex", "application/x-latex");
+ mimeTypes.put("m3u", "audio/x-mpegurl");
+ mimeTypes.put("mac", "image/x-macpaint");
+ mimeTypes.put("man", "application/x-troff-man");
+ mimeTypes.put("me", "application/x-troff-me");
+ mimeTypes.put("mid", "audio/x-midi");
+ mimeTypes.put("midi", "audio/x-midi");
+ mimeTypes.put("mif", "application/x-mif");
+ mimeTypes.put("mov", "video/quicktime");
+ mimeTypes.put("movie", "video/x-sgi-movie");
+ mimeTypes.put("mp1", "audio/x-mpeg");
+ mimeTypes.put("mp2", "audio/x-mpeg");
+ mimeTypes.put("mp3", "audio/x-mpeg");
+ mimeTypes.put("mpa", "audio/x-mpeg");
+ mimeTypes.put("mpe", "video/mpeg");
+ mimeTypes.put("mpeg", "video/mpeg");
+ mimeTypes.put("mpega", "audio/x-mpeg");
+ mimeTypes.put("mpg", "video/mpeg");
+ mimeTypes.put("mpv2", "video/mpeg2");
+ mimeTypes.put("ms", "application/x-wais-source");
+ mimeTypes.put("nc", "application/x-netcdf");
+ mimeTypes.put("oda", "application/oda");
+ mimeTypes.put("pbm", "image/x-portable-bitmap");
+ mimeTypes.put("pct", "image/pict");
+ mimeTypes.put("pdf", "application/pdf");
+ mimeTypes.put("pgm", "image/x-portable-graymap");
+ mimeTypes.put("pic", "image/pict");
+ mimeTypes.put("pict", "image/pict");
+ mimeTypes.put("pls", "audio/x-scpls");
+ mimeTypes.put("png", "image/png");
+ mimeTypes.put("pnm", "image/x-portable-anymap");
+ mimeTypes.put("pnt", "image/x-macpaint");
+ mimeTypes.put("ppm", "image/x-portable-pixmap");
+ mimeTypes.put("ppt", "application/powerpoint");
+ mimeTypes.put("ps", "application/postscript");
+ mimeTypes.put("psd", "image/x-photoshop");
+ mimeTypes.put("qt", "video/quicktime");
+ mimeTypes.put("qti", "image/x-quicktime");
+ mimeTypes.put("qtif", "image/x-quicktime");
+ mimeTypes.put("ras", "image/x-cmu-raster");
+ mimeTypes.put("rgb", "image/x-rgb");
+ mimeTypes.put("rm", "application/vnd.rn-realmedia");
+ mimeTypes.put("roff", "application/x-troff");
+ mimeTypes.put("rtf", "application/rtf");
+ mimeTypes.put("rtx", "text/richtext");
+ mimeTypes.put("sh", "application/x-sh");
+ mimeTypes.put("shar", "application/x-shar");
+ mimeTypes.put("smf", "audio/x-midi");
+ mimeTypes.put("sit", "application/x-stuffit");
+ mimeTypes.put("snd", "audio/basic");
+ mimeTypes.put("src", "application/x-wais-source");
+ mimeTypes.put("sv4cpio", "application/x-sv4cpio");
+ mimeTypes.put("sv4crc", "application/x-sv4crc");
+ mimeTypes.put("swf", "application/x-shockwave-flash");
+ mimeTypes.put("t", "application/x-troff");
+ mimeTypes.put("tar", "application/x-tar");
+ mimeTypes.put("tcl", "application/x-tcl");
+ mimeTypes.put("tex", "application/x-tex");
+ mimeTypes.put("texi", "application/x-texinfo");
+ mimeTypes.put("texinfo", "application/x-texinfo");
+ mimeTypes.put("tif", "image/tiff");
+ mimeTypes.put("tiff", "image/tiff");
+ mimeTypes.put("tr", "application/x-troff");
+ mimeTypes.put("tsv", "text/tab-separated-values");
+ mimeTypes.put("txt", "text/plain");
+ mimeTypes.put("ulw", "audio/basic");
+ mimeTypes.put("ustar", "application/x-ustar");
+ mimeTypes.put("xbm", "image/x-xbitmap");
+ mimeTypes.put("xht", "application/xhtml+xml");
+ mimeTypes.put("xhtml", "application/xhtml+xml");
+ mimeTypes.put("xml", "text/xml");
+ mimeTypes.put("xpm", "image/x-xpixmap");
+ mimeTypes.put("xsl", "text/xml");
+ mimeTypes.put("xwd", "image/x-xwindowdump");
+ mimeTypes.put("wav", "audio/x-wav");
+ mimeTypes.put("svg", "image/svg+xml");
+ mimeTypes.put("svgz", "image/svg+xml");
+ mimeTypes.put("vsd", "application/x-visio");
+ mimeTypes.put("wbmp", "image/vnd.wap.wbmp");
+ mimeTypes.put("wml", "text/vnd.wap.wml");
+ mimeTypes.put("wmlc", "application/vnd.wap.wmlc");
+ mimeTypes.put("wmls", "text/vnd.wap.wmlscript");
+ mimeTypes.put("wmlscriptc", "application/vnd.wap.wmlscriptc");
+ mimeTypes.put("wrl", "x-world/x-vrml");
+ mimeTypes.put("Z", "application/x-compress");
+ mimeTypes.put("z", "application/x-compress");
+ mimeTypes.put("zip", "application/zip");
+ }
+
+ /**
+ * Checks to see whether or not a client's file is out of date relative to the
+ * original.
+ */
+ private boolean isNotModified(HttpServletRequest request, long ageOfServerCopy) {
+ // The age of the server copy *must* have the milliseconds truncated.
+ // Since milliseconds isn't part of the GMT format, failure to truncate
+ // will leave the file in a state where it appears constantly out of date
+ // and yet it can never get in sync because the Last-Modified date keeps
+ // truncating off the milliseconds part on its way out.
+ //
+ ageOfServerCopy -= (ageOfServerCopy % 1000);
+
+ long ageOfClientCopy = 0;
+ String ifModifiedSince = request.getHeader("If-Modified-Since");
+ if (ifModifiedSince != null) {
+ // Rip off any additional stuff at the end, such as "; length="
+ // (IE does add this).
+ //
+ int lastSemi = ifModifiedSince.lastIndexOf(';');
+ if (lastSemi != -1) {
+ ifModifiedSince = ifModifiedSince.substring(0, lastSemi);
+ }
+ ageOfClientCopy = HttpHeaders.fromInternetDateFormat(ifModifiedSince);
+ }
+
+ if (ageOfClientCopy >= ageOfServerCopy) {
+ // The client already has a good copy.
+ //
+ return true;
+ } else {
+ // The client needs a fresh copy of the requested file.
+ //
+ return false;
+ }
+ }
+
+ private void maybeIssueXhtmlWarning(TreeLogger logger, String mimeType,
+ String path) {
+ if (!XHTML_MIME_TYPE.equals(mimeType)) {
+ return;
+ }
+
+ String msg = "File was returned with content-type of \"" + mimeType
+ + "\". GWT requires browser features that are not available to "
+ + "documents with this content-type.";
+
+ int ix = path.lastIndexOf('.');
+ if (ix >= 0 && ix < path.length()) {
+ String base = path.substring(0, ix);
+ msg += " Consider renaming \"" + path + "\" to \"" + base + ".html\".";
+ }
+
+ logger.log(TreeLogger.WARN, msg, null);
+ }
+
+ private void sendErrorResponse(HttpServletResponse response, int statusCode,
+ String msg) throws IOException {
+ response.setContentType("text/html");
+ response.getWriter().println(msg);
+ response.setStatus(statusCode);
+ }
+
+ /**
+ * Sets the Cache-control and Expires headers in the response based on the
+ * supplied cache time.
+ *
+ * Expires is used in addition to Cache-control for older clients or proxies
+ * which may not properly understand Cache-control.
+ *
+ * @param response the HttpServletResponse to update
+ * @param cacheTime non-negative number of seconds to cache the response; 0
+ * means specifically do not allow caching at all.
+ * @throws IllegalArgumentException if cacheTime is negative
+ */
+ private void setResponseCacheHeaders(HttpServletResponse response,
+ long cacheTime) {
+ long expires;
+ if (cacheTime < 0) {
+ throw new IllegalArgumentException("cacheTime of " + cacheTime
+ + " is negative");
+ }
+ if (cacheTime > 0) {
+ // Expire the specified seconds in the future.
+ expires = new Date().getTime() + cacheTime * HttpHeaders.MS_SEC;
+ } else {
+ // Prevent caching by using a time in the past for cache expiration.
+ // Use January 2, 1970 00:00:00, to account for timezone changes
+ // in case a browser tries to convert to a local timezone first
+ // 0=Jan 1, so add 1 day's worth of milliseconds to get Jan 2
+ expires = HttpHeaders.SEC_DAY * HttpHeaders.MS_SEC;
+ }
+ response.setHeader(HttpHeaders.CACHE_CONTROL,
+ HttpHeaders.CACHE_CONTROL_MAXAGE + cacheTime);
+ String expiresString = HttpHeaders.toInternetDateFormat(expires);
+ response.setHeader(HttpHeaders.EXPIRES, expiresString);
+ }
+
+ private boolean shouldAutoGenerateResources() {
+ ServletContext servletContext = getServletContext();
+ final String attr = "com.google.gwt.dev.shell.shouldAutoGenerateResources";
+ Boolean attrValue = (Boolean) servletContext.getAttribute(attr);
+ if (attrValue == null) {
+ return true;
+ }
+ return attrValue;
+ }
+
+ private void streamOut(InputStream in, OutputStream out, int bufferSize)
+ throws IOException {
+ assert (bufferSize >= 0);
+
+ byte[] buffer = new byte[bufferSize];
+ int bytesRead = 0;
+ while (true) {
+ bytesRead = in.read(buffer);
+ if (bytesRead >= 0) {
+ // Copy the bytes out.
+ out.write(buffer, 0, bytesRead);
+ } else {
+ // End of input stream.
+ out.flush();
+ return;
+ }
+ }
+ }
+
+ private HttpServlet tryGetOrLoadServlet(TreeLogger logger,
+ ModuleDef moduleDef, String className) {
+
+ // Maps className to live servlet for this module.
+ Map<String, HttpServlet> moduleServlets;
+ synchronized (loadedServletsByModuleAndClassName) {
+ moduleServlets = loadedServletsByModuleAndClassName.get(moduleDef);
+ if (moduleServlets == null) {
+ moduleServlets = new HashMap<String, HttpServlet>();
+ loadedServletsByModuleAndClassName.put(moduleDef, moduleServlets);
+ }
+ }
+
+ synchronized (moduleServlets) {
+ HttpServlet servlet = moduleServlets.get(className);
+ if (servlet != null) {
+ // Found it.
+ //
+ return servlet;
+ }
+
+ // Try to load and instantiate it.
+ //
+ Throwable caught = null;
+ try {
+ Class<?> servletClass = Class.forName(className);
+ Object newInstance = servletClass.newInstance();
+ if (!(newInstance instanceof HttpServlet)) {
+ logger.log(TreeLogger.ERROR,
+ "Not compatible with HttpServlet: " + className
+ + " (does your service extend RemoteServiceServlet?)", null);
+ return null;
+ }
+
+ // Success. Hang onto the instance so we can reuse it.
+ //
+ servlet = (HttpServlet) newInstance;
+
+ // We create proxies for ServletContext and ServletConfig to enable
+ // RemoteServiceServlets to load public and generated resources via
+ // ServletContext.getResourceAsStream()
+ //
+ ServletContext context = new HostedModeServletContextProxy(
+ getServletContext(), moduleDef, getShellWorkDirs());
+ ServletConfig config = new HostedModeServletConfigProxy(
+ getServletConfig(), context);
+
+ servlet.init(config);
+
+ moduleServlets.put(className, servlet);
+ return servlet;
+ } catch (ClassNotFoundException e) {
+ caught = e;
+ } catch (InstantiationException e) {
+ caught = e;
+ } catch (IllegalAccessException e) {
+ caught = e;
+ } catch (ServletException e) {
+ caught = e;
+ }
+ String msg = "Unable to instantiate '" + className + "'";
+ logger.log(TreeLogger.ERROR, msg, caught);
+ return null;
+ }
+ }
+}
diff --git a/dev/core/src/com/google/gwt/dev/shell/HostedModeServletContextProxy.java b/dev/core/src/com/google/gwt/dev/shell/HostedModeServletContextProxy.java
new file mode 100644
index 0000000..d6b321e
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/shell/HostedModeServletContextProxy.java
@@ -0,0 +1,338 @@
+/*
+ * Copyright 2007 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;
+
+import com.google.gwt.dev.cfg.ModuleDef;
+import com.google.gwt.dev.resource.Resource;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.ref.WeakReference;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Enumeration;
+import java.util.Set;
+
+import javax.servlet.RequestDispatcher;
+import javax.servlet.Servlet;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+
+/**
+ * ServletContext proxy that implements the getResource and getResourceAsStream
+ * members so that they can work with the {@link GWTShellServlet}.
+ */
+class HostedModeServletContextProxy implements ServletContext {
+ private final ServletContext context;
+ /**
+ * Avoid pinning my moduleDef.
+ */
+ private final WeakReference<ModuleDef> moduleDefRef;
+ private final WorkDirs workDirs;
+
+ HostedModeServletContextProxy(ServletContext context, ModuleDef moduleDef,
+ WorkDirs workDirs) {
+ this.context = context;
+ this.moduleDefRef = new WeakReference<ModuleDef>(moduleDef);
+ this.workDirs = workDirs;
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @see javax.servlet.ServletContext#getAttribute(java.lang.String)
+ */
+ public Object getAttribute(String arg0) {
+ return context.getAttribute(arg0);
+ }
+
+ /**
+ * @return
+ * @see javax.servlet.ServletContext#getAttributeNames()
+ */
+ @SuppressWarnings("unchecked")
+ public Enumeration<String> getAttributeNames() {
+ return context.getAttributeNames();
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @see javax.servlet.ServletContext#getContext(java.lang.String)
+ */
+ public ServletContext getContext(String arg0) {
+ return context.getContext(arg0);
+ }
+
+ public String getContextPath() {
+ return context.getContextPath();
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @see javax.servlet.ServletContext#getInitParameter(java.lang.String)
+ */
+ public String getInitParameter(String arg0) {
+ return context.getInitParameter(arg0);
+ }
+
+ /**
+ * @return
+ * @see javax.servlet.ServletContext#getInitParameterNames()
+ */
+ public Enumeration<?> getInitParameterNames() {
+ return context.getInitParameterNames();
+ }
+
+ /**
+ * @return
+ * @see javax.servlet.ServletContext#getMajorVersion()
+ */
+ public int getMajorVersion() {
+ return context.getMajorVersion();
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @see javax.servlet.ServletContext#getMimeType(java.lang.String)
+ */
+ public String getMimeType(String arg0) {
+ return context.getMimeType(arg0);
+ }
+
+ /**
+ * @return
+ * @see javax.servlet.ServletContext#getMinorVersion()
+ */
+ public int getMinorVersion() {
+ return context.getMinorVersion();
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @see javax.servlet.ServletContext#getNamedDispatcher(java.lang.String)
+ */
+ public RequestDispatcher getNamedDispatcher(String arg0) {
+ return context.getNamedDispatcher(arg0);
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @see javax.servlet.ServletContext#getRealPath(java.lang.String)
+ */
+ public String getRealPath(String arg0) {
+ return context.getRealPath(arg0);
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @see javax.servlet.ServletContext#getRequestDispatcher(java.lang.String)
+ */
+ public RequestDispatcher getRequestDispatcher(String arg0) {
+ return context.getRequestDispatcher(arg0);
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @throws MalformedURLException
+ * @see javax.servlet.ServletContext#getResource(java.lang.String)
+ */
+ @SuppressWarnings("deprecation")
+ public URL getResource(String path) throws MalformedURLException {
+ ModuleDef moduleDef = moduleDefRef.get();
+ assert (moduleDef != null) : "GWTShellServlet should have guaranteed that a"
+ + " live servlet will never process a request for a dead module; if you"
+ + " are using this servlet outside the context of processing a call,"
+ + " then don't do that";
+
+ String moduleContext = "/" + moduleDef.getName() + "/";
+ if (!path.startsWith(moduleContext)) {
+ // Check for a renamed module
+ moduleContext = "/" + moduleDef.getCanonicalName() + "/";
+ if (!path.startsWith(moduleContext)) {
+ // This path is in a different context; just return null
+ return null;
+ }
+ }
+
+ String partialPath = path.substring(moduleContext.length());
+
+ // Try to get the resource from the application's public path
+ Resource publicResource = moduleDef.findPublicFile(partialPath);
+ if (publicResource != null) {
+ return publicResource.getURL();
+ }
+
+ // Otherwise try the path in the shell's public generated directory
+ File shellDir = workDirs.getShellPublicGenDir(moduleDef);
+ File requestedFile = new File(shellDir, partialPath);
+ if (requestedFile.exists()) {
+ return requestedFile.toURI().toURL();
+ }
+
+ /*
+ * If the user is coming from compiled web-mode, check the linker output
+ * directory for the file. We'll default to using the output directory of
+ * the first linker defined in the <set-linker> tab.
+ */
+ File linkDir = workDirs.getCompilerOutputDir(moduleDef);
+ requestedFile = new File(linkDir, partialPath);
+ if (requestedFile.exists()) {
+ try {
+ return requestedFile.toURI().toURL();
+ } catch (MalformedURLException e) {
+ // ignore since it was speculative anyway
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @see javax.servlet.ServletContext#getResourceAsStream(java.lang.String)
+ */
+ public InputStream getResourceAsStream(String arg0) {
+ URL url;
+ try {
+ url = getResource(arg0);
+ if (url != null) {
+ return url.openStream();
+ }
+ } catch (MalformedURLException e) {
+ // Ignore the exception; return null
+ } catch (IOException e) {
+ // Ignore the exception; return null
+ }
+
+ return null;
+ }
+
+ /**
+ *
+ * @param path
+ * @return
+ * @see javax.servlet.ServletContext#getResourcePaths(java.lang.String)
+ */
+ @SuppressWarnings("unchecked")
+ public Set<String> getResourcePaths(String path) {
+ return context.getResourcePaths(path);
+ }
+
+ /**
+ * @return
+ * @see javax.servlet.ServletContext#getServerInfo()
+ */
+ public String getServerInfo() {
+ return context.getServerInfo();
+ }
+
+ /**
+ * @param arg0
+ * @return
+ * @throws ServletException
+ * @deprecated
+ * @see javax.servlet.ServletContext#getServlet(java.lang.String)
+ */
+ @Deprecated
+ public Servlet getServlet(String arg0) throws ServletException {
+ return context.getServlet(arg0);
+ }
+
+ /**
+ * @return
+ * @see javax.servlet.ServletContext#getServletContextName()
+ */
+ public String getServletContextName() {
+ return context.getServletContextName();
+ }
+
+ /**
+ * @return
+ * @deprecated
+ * @see javax.servlet.ServletContext#getServletNames()
+ */
+ @Deprecated
+ @SuppressWarnings("unchecked")
+ public Enumeration<String> getServletNames() {
+ return context.getServletNames();
+ }
+
+ /**
+ * @return
+ * @deprecated
+ * @see javax.servlet.ServletContext#getServlets()
+ */
+ @Deprecated
+ @SuppressWarnings("unchecked")
+ public Enumeration<Servlet> getServlets() {
+ return context.getServlets();
+ }
+
+ /**
+ * @param arg0
+ * @param arg1
+ * @deprecated
+ * @see javax.servlet.ServletContext#log(java.lang.Exception,
+ * java.lang.String)
+ */
+ @Deprecated
+ public void log(Exception arg0, String arg1) {
+ context.log(arg0, arg1);
+ }
+
+ /**
+ * @param arg0
+ * @see javax.servlet.ServletContext#log(java.lang.String)
+ */
+ public void log(String arg0) {
+ context.log(arg0);
+ }
+
+ /**
+ * @param arg0
+ * @param arg1
+ * @see javax.servlet.ServletContext#log(java.lang.String,java.lang.Throwable)
+ */
+ public void log(String arg0, Throwable arg1) {
+ context.log(arg0, arg1);
+ }
+
+ /**
+ * @param arg0
+ * @see javax.servlet.ServletContext#removeAttribute(java.lang.String)
+ */
+ public void removeAttribute(String arg0) {
+ context.removeAttribute(arg0);
+ }
+
+ /**
+ * @param arg0
+ * @param arg1
+ * @see javax.servlet.ServletContext#setAttribute(java.lang.String,java.lang.Object)
+ */
+ public void setAttribute(String arg0, Object arg1) {
+ context.setAttribute(arg0, arg1);
+ }
+}
diff --git a/dev/core/src/com/google/gwt/dev/shell/tomcat/CatalinaLoggerAdapter.java b/dev/core/src/com/google/gwt/dev/shell/tomcat/CatalinaLoggerAdapter.java
new file mode 100644
index 0000000..9cf2d95
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/shell/tomcat/CatalinaLoggerAdapter.java
@@ -0,0 +1,75 @@
+/*
+ * 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 org.apache.catalina.logger.LoggerBase;
+
+class CatalinaLoggerAdapter extends LoggerBase {
+
+ private final TreeLogger logger;
+
+ public CatalinaLoggerAdapter(TreeLogger logger) {
+ this.logger = logger;
+ }
+
+ @Override
+ public void log(Exception exception, String msg) {
+ logger.log(TreeLogger.WARN, msg, exception);
+ }
+
+ @Override
+ public void log(String msg) {
+ logger.log(TreeLogger.INFO, msg, null);
+ }
+
+ @Override
+ public void log(String message, int verbosity) {
+ TreeLogger.Type type = mapVerbosityToLogType(verbosity);
+ logger.log(type, message, null);
+ }
+
+ @Override
+ public void log(String msg, Throwable throwable) {
+ logger.log(TreeLogger.WARN, msg, throwable);
+ }
+
+ @Override
+ public void log(String message, Throwable throwable, int verbosity) {
+ TreeLogger.Type type = mapVerbosityToLogType(verbosity);
+ logger.log(type, message, throwable);
+ }
+
+ private TreeLogger.Type mapVerbosityToLogType(int verbosity) {
+ switch (verbosity) {
+ case LoggerBase.FATAL:
+ case LoggerBase.ERROR:
+ case LoggerBase.WARNING:
+ return TreeLogger.WARN;
+
+ case LoggerBase.INFORMATION:
+ return TreeLogger.DEBUG;
+ case LoggerBase.DEBUG:
+ return TreeLogger.SPAM;
+
+ default:
+ // really, this was an unexpected type
+ return TreeLogger.WARN;
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/dev/core/src/com/google/gwt/dev/shell/tomcat/CommonsLoggerAdapter.java b/dev/core/src/com/google/gwt/dev/shell/tomcat/CommonsLoggerAdapter.java
new file mode 100644
index 0000000..d071d2a
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/shell/tomcat/CommonsLoggerAdapter.java
@@ -0,0 +1,119 @@
+/*
+ * 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;
+
+/**
+ * Maps Tomcat's commons logger onto the GWT shell's tree logger.
+ */
+public class CommonsLoggerAdapter implements org.apache.commons.logging.Log {
+
+ private TreeLogger log;
+
+ /**
+ * @param name unused
+ */
+ public CommonsLoggerAdapter(String name) {
+ // NOTE: this is ugly, but I don't know of any other way to get a
+ // non-static log to which we can delegate.
+ //
+ log = EmbeddedTomcatServer.sTomcat.getLogger();
+ }
+
+ public void debug(Object message) {
+ doLog(TreeLogger.SPAM, message, null);
+ }
+
+ public void debug(Object message, Throwable t) {
+ doLog(TreeLogger.SPAM, message, t);
+ }
+
+ public void error(Object message) {
+ doLog(TreeLogger.WARN, message, null);
+ }
+
+ public void error(Object message, Throwable t) {
+ doLog(TreeLogger.WARN, message, t);
+ }
+
+ public void fatal(Object message) {
+ doLog(TreeLogger.WARN, message, null);
+ }
+
+ public void fatal(Object message, Throwable t) {
+ doLog(TreeLogger.WARN, message, t);
+ }
+
+ public void info(Object message) {
+ // Intentionally low-level to us.
+ doLog(TreeLogger.TRACE, message, null);
+ }
+
+ public void info(Object message, Throwable t) {
+ // Intentionally low-level to us.
+ doLog(TreeLogger.TRACE, message, t);
+ }
+
+ public boolean isDebugEnabled() {
+ return log.isLoggable(TreeLogger.SPAM);
+ }
+
+ public boolean isErrorEnabled() {
+ return log.isLoggable(TreeLogger.WARN);
+ }
+
+ public boolean isFatalEnabled() {
+ return log.isLoggable(TreeLogger.WARN);
+ }
+
+ public boolean isInfoEnabled() {
+ // Intentionally low-level to us.
+ return log.isLoggable(TreeLogger.TRACE);
+ }
+
+ public boolean isTraceEnabled() {
+ // Intentionally low-level to us.
+ return log.isLoggable(TreeLogger.SPAM);
+ }
+
+ public boolean isWarnEnabled() {
+ return log.isLoggable(TreeLogger.WARN);
+ }
+
+ public void trace(Object message) {
+ // Intentionally low-level to us.
+ doLog(TreeLogger.DEBUG, message, null);
+ }
+
+ public void trace(Object message, Throwable t) {
+ // Intentionally low-level to us.
+ doLog(TreeLogger.DEBUG, message, t);
+ }
+
+ public void warn(Object message) {
+ doLog(TreeLogger.WARN, message, null);
+ }
+
+ public void warn(Object message, Throwable t) {
+ doLog(TreeLogger.WARN, message, t);
+ }
+
+ private void doLog(TreeLogger.Type type, Object message, Throwable t) {
+ String msg = message.toString();
+ log.log(type, msg, t);
+ }
+}
\ No newline at end of file
diff --git a/dev/core/src/com/google/gwt/dev/shell/tomcat/EmbeddedTomcatServer.java b/dev/core/src/com/google/gwt/dev/shell/tomcat/EmbeddedTomcatServer.java
new file mode 100644
index 0000000..e7d27ac
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/shell/tomcat/EmbeddedTomcatServer.java
@@ -0,0 +1,436 @@
+/*
+ * 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);
+ }
+}
diff --git a/dev/core/src/org/apache/COPYING b/dev/core/src/org/apache/COPYING
new file mode 100644
index 0000000..d9a10c0
--- /dev/null
+++ b/dev/core/src/org/apache/COPYING
@@ -0,0 +1,176 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
diff --git a/dev/core/src/org/apache/catalina/loader/WebappClassLoader.java b/dev/core/src/org/apache/catalina/loader/WebappClassLoader.java
new file mode 100644
index 0000000..f941fad
--- /dev/null
+++ b/dev/core/src/org/apache/catalina/loader/WebappClassLoader.java
@@ -0,0 +1,2169 @@
+/*
+ * Copyright 1999,2004 The Apache Software Foundation.
+ *
+ * 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.
+ */
+// Modified by Google.
+
+package org.apache.catalina.loader;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FilePermission;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.security.AccessControlException;
+import java.security.AccessController;
+import java.security.CodeSource;
+import java.security.Permission;
+import java.security.PermissionCollection;
+import java.security.Policy;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Vector;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.Manifest;
+import java.util.jar.Attributes.Name;
+
+import javax.naming.NameClassPair;
+import javax.naming.NamingEnumeration;
+import javax.naming.NamingException;
+import javax.naming.directory.DirContext;
+
+import org.apache.catalina.Lifecycle;
+import org.apache.catalina.LifecycleException;
+import org.apache.catalina.LifecycleListener;
+import org.apache.catalina.util.StringManager;
+import org.apache.naming.JndiPermission;
+import org.apache.naming.resources.Resource;
+import org.apache.naming.resources.ResourceAttributes;
+import org.apache.tomcat.util.compat.JdkCompat;
+
+/**
+ * Specialized web application class loader.
+ * <p>
+ * This class loader is a full reimplementation of the
+ * <code>URLClassLoader</code> from the JDK. It is desinged to be fully
+ * compatible with a normal <code>URLClassLoader</code>, although its internal
+ * behavior may be completely different.
+ * <p>
+ * <strong>IMPLEMENTATION NOTE</strong> - This class loader faithfully follows
+ * the delegation model recommended in the specification. The system class
+ * loader will be queried first, then the local repositories, and only then
+ * delegation to the parent class loader will occur. This allows the web
+ * application to override any shared class except the classes from J2SE.
+ * Special handling is provided from the JAXP XML parser interfaces, the JNDI
+ * interfaces, and the classes from the servlet API, which are never loaded
+ * from the webapp repository.
+ * <p>
+ * <strong>IMPLEMENTATION NOTE</strong> - Due to limitations in Jasper
+ * compilation technology, any repository which contains classes from
+ * the servlet API will be ignored by the class loader.
+ * <p>
+ * <strong>IMPLEMENTATION NOTE</strong> - The class loader generates source
+ * URLs which include the full JAR URL when a class is loaded from a JAR file,
+ * which allows setting security permission at the class level, even when a
+ * class is contained inside a JAR.
+ * <p>
+ * <strong>IMPLEMENTATION NOTE</strong> - Local repositories are searched in
+ * the order they are added via the initial constructor and/or any subsequent
+ * calls to <code>addRepository()</code> or <code>addJar()</code>.
+ * <p>
+ * <strong>IMPLEMENTATION NOTE</strong> - No check for sealing violations or
+ * security is made unless a security manager is present.
+ *
+ * @author Remy Maucherat
+ * @author Craig R. McClanahan
+ * @version $Revision: 1.34 $ $Date: 2004/05/26 15:47:40 $
+ */
+public class WebappClassLoader
+ extends URLClassLoader
+ implements Reloader, Lifecycle
+ {
+
+ private static org.apache.commons.logging.Log log=
+ org.apache.commons.logging.LogFactory.getLog( WebappClassLoader.class );
+
+ protected class PrivilegedFindResource
+ implements PrivilegedAction {
+
+ private File file;
+ private String path;
+
+ PrivilegedFindResource(File file, String path) {
+ this.file = file;
+ this.path = path;
+ }
+
+ public Object run() {
+ return findResourceInternal(file, path);
+ }
+
+ }
+
+
+ // ------------------------------------------------------- Static Variables
+
+
+ /**
+ * The set of trigger classes that will cause a proposed repository not
+ * to be added if this class is visible to the class loader that loaded
+ * this factory class. Typically, trigger classes will be listed for
+ * components that have been integrated into the JDK for later versions,
+ * but where the corresponding JAR files are required to run on
+ * earlier versions.
+ */
+ private static final String[] triggers = {
+ "javax.servlet.Servlet" // Servlet API
+ };
+
+ /**
+ * Jdk Compatibility Support.
+ */
+ private static JdkCompat jdkCompat = JdkCompat.getJdkCompat();
+
+ /**
+ * Set of package names which are not allowed to be loaded from a webapp
+ * class loader without delegating first.
+ */
+ private static final String[] packageTriggers = {
+ "javax", // Java extensions
+ "org.xml.sax", // SAX 1 & 2
+ "org.w3c.dom", // DOM 1 & 2
+ "org.apache.xerces", // Xerces 1 & 2
+ "org.apache.xalan" // Xalan
+ };
+
+
+ /**
+ * The string manager for this package.
+ */
+ protected static final StringManager sm =
+ StringManager.getManager(Constants.Package);
+
+
+ // ----------------------------------------------------------- Constructors
+
+
+ /**
+ * Construct a new ClassLoader with no defined repositories and no
+ * parent ClassLoader.
+ */
+ public WebappClassLoader() {
+
+ super(new URL[0]);
+ this.parent = getParent();
+ system = getSystemClassLoader();
+ securityManager = System.getSecurityManager();
+
+ if (securityManager != null) {
+ refreshPolicy();
+ }
+
+ }
+
+
+ /**
+ * Construct a new ClassLoader with no defined repositories and no
+ * parent ClassLoader.
+ */
+ public WebappClassLoader(ClassLoader parent) {
+
+ super(new URL[0], parent);
+
+ this.parent = getParent();
+
+ system = getSystemClassLoader();
+ securityManager = System.getSecurityManager();
+
+ if (securityManager != null) {
+ refreshPolicy();
+ }
+ }
+
+
+ // ----------------------------------------------------- Instance Variables
+
+
+ /**
+ * Associated directory context giving access to the resources in this
+ * webapp.
+ */
+ protected DirContext resources = null;
+
+
+ /**
+ * The cache of ResourceEntry for classes and resources we have loaded,
+ * keyed by resource name.
+ */
+ protected HashMap resourceEntries = new HashMap();
+
+
+ /**
+ * The list of not found resources.
+ */
+ protected HashMap notFoundResources = new HashMap();
+
+
+ /**
+ * The debugging detail level of this component.
+ */
+ protected int debug = 0;
+
+
+ /**
+ * Should this class loader delegate to the parent class loader
+ * <strong>before</strong> searching its own repositories (i.e. the
+ * usual Java2 delegation model)? If set to <code>false</code>,
+ * this class loader will search its own repositories first, and
+ * delegate to the parent only if the class or resource is not
+ * found locally.
+ */
+ protected boolean delegate = false;
+
+
+ /**
+ * Last time a JAR was accessed.
+ */
+ protected long lastJarAccessed = 0L;
+
+
+ /**
+ * The list of local repositories, in the order they should be searched
+ * for locally loaded classes or resources.
+ */
+ protected String[] repositories = new String[0];
+
+
+ /**
+ * Repositories URLs, used to cache the result of getURLs.
+ */
+ protected URL[] repositoryURLs = null;
+
+
+ /**
+ * Repositories translated as path in the work directory (for Jasper
+ * originally), but which is used to generate fake URLs should getURLs be
+ * called.
+ */
+ protected File[] files = new File[0];
+
+
+ /**
+ * The list of JARs, in the order they should be searched
+ * for locally loaded classes or resources.
+ */
+ protected JarFile[] jarFiles = new JarFile[0];
+
+
+ /**
+ * The list of JARs, in the order they should be searched
+ * for locally loaded classes or resources.
+ */
+ protected File[] jarRealFiles = new File[0];
+
+
+ /**
+ * The path which will be monitored for added Jar files.
+ */
+ protected String jarPath = null;
+
+
+ /**
+ * The list of JARs, in the order they should be searched
+ * for locally loaded classes or resources.
+ */
+ protected String[] jarNames = new String[0];
+
+
+ /**
+ * The list of JARs last modified dates, in the order they should be
+ * searched for locally loaded classes or resources.
+ */
+ protected long[] lastModifiedDates = new long[0];
+
+
+ /**
+ * The list of resources which should be checked when checking for
+ * modifications.
+ */
+ protected String[] paths = new String[0];
+
+
+ /**
+ * A list of read File and Jndi Permission's required if this loader
+ * is for a web application context.
+ */
+ private ArrayList permissionList = new ArrayList();
+
+
+ /**
+ * Path where resources loaded from JARs will be extracted.
+ */
+ private File loaderDir = null;
+
+
+ /**
+ * The PermissionCollection for each CodeSource for a web
+ * application context.
+ */
+ private HashMap loaderPC = new HashMap();
+
+
+ /**
+ * Instance of the SecurityManager installed.
+ */
+ private SecurityManager securityManager = null;
+
+
+ /**
+ * The parent class loader.
+ */
+ private ClassLoader parent = null;
+
+
+ /**
+ * The system class loader.
+ */
+ private ClassLoader system = null;
+
+
+ /**
+ * Has this component been started?
+ */
+ protected boolean started = false;
+
+
+ /**
+ * Has external repositories.
+ */
+ protected boolean hasExternalRepositories = false;
+
+
+ /**
+ * All permission.
+ */
+ private Permission allPermission = new java.security.AllPermission();
+
+
+ // ------------------------------------------------------------- Properties
+
+
+ /**
+ * Get associated resources.
+ */
+ public DirContext getResources() {
+
+ return this.resources;
+
+ }
+
+
+ /**
+ * Set associated resources.
+ */
+ public void setResources(DirContext resources) {
+
+ this.resources = resources;
+
+ }
+
+
+ /**
+ * Return the debugging detail level for this component.
+ */
+ public int getDebug() {
+
+ return (this.debug);
+
+ }
+
+
+ /**
+ * Set the debugging detail level for this component.
+ *
+ * @param debug The new debugging detail level
+ */
+ public void setDebug(int debug) {
+
+ this.debug = debug;
+
+ }
+
+
+ /**
+ * Return the "delegate first" flag for this class loader.
+ */
+ public boolean getDelegate() {
+
+ return (this.delegate);
+
+ }
+
+
+ /**
+ * Set the "delegate first" flag for this class loader.
+ *
+ * @param delegate The new "delegate first" flag
+ */
+ public void setDelegate(boolean delegate) {
+
+ this.delegate = delegate;
+
+ }
+
+
+ /**
+ * If there is a Java SecurityManager create a read FilePermission
+ * or JndiPermission for the file directory path.
+ *
+ * @param path file directory path
+ */
+ public void addPermission(String path) {
+ if (path == null) {
+ return;
+ }
+
+ if (securityManager != null) {
+ Permission permission = null;
+ if( path.startsWith("jndi:") || path.startsWith("jar:jndi:") ) {
+ if (!path.endsWith("/")) {
+ path = path + "/";
+ }
+ permission = new JndiPermission(path + "*");
+ addPermission(permission);
+ } else {
+ if (!path.endsWith(File.separator)) {
+ permission = new FilePermission(path, "read");
+ addPermission(permission);
+ path = path + File.separator;
+ }
+ permission = new FilePermission(path + "-", "read");
+ addPermission(permission);
+ }
+ }
+ }
+
+
+ /**
+ * If there is a Java SecurityManager create a read FilePermission
+ * or JndiPermission for URL.
+ *
+ * @param url URL for a file or directory on local system
+ */
+ public void addPermission(URL url) {
+ if (url != null) {
+ addPermission(url.toString());
+ }
+ }
+
+
+ /**
+ * If there is a Java SecurityManager create a Permission.
+ *
+ * @param url URL for a file or directory on local system
+ */
+ public void addPermission(Permission permission) {
+ if ((securityManager != null) && (permission != null)) {
+ permissionList.add(permission);
+ }
+ }
+
+
+ /**
+ * Return the JAR path.
+ */
+ public String getJarPath() {
+
+ return this.jarPath;
+
+ }
+
+
+ /**
+ * Change the Jar path.
+ */
+ public void setJarPath(String jarPath) {
+
+ this.jarPath = jarPath;
+
+ }
+
+
+ /**
+ * Change the work directory.
+ */
+ public void setWorkDir(File workDir) {
+ this.loaderDir = new File(workDir, "loader");
+ }
+
+
+ // ------------------------------------------------------- Reloader Methods
+
+
+ /**
+ * Add a new repository to the set of places this ClassLoader can look for
+ * classes to be loaded.
+ *
+ * @param repository Name of a source of classes to be loaded, such as a
+ * directory pathname, a JAR file pathname, or a ZIP file pathname
+ *
+ * @exception IllegalArgumentException if the specified repository is
+ * invalid or does not exist
+ */
+ public void addRepository(String repository) {
+
+ // Ignore any of the standard repositories, as they are set up using
+ // either addJar or addRepository
+ if (repository.startsWith("/WEB-INF/lib")
+ || repository.startsWith("/WEB-INF/classes"))
+ return;
+
+ // Add this repository to our underlying class loader
+ try {
+ URL url = new URL(repository);
+ super.addURL(url);
+ hasExternalRepositories = true;
+ repositoryURLs = null;
+ } catch (MalformedURLException e) {
+ IllegalArgumentException iae = new IllegalArgumentException
+ ("Invalid repository: " + repository);
+ jdkCompat.chainException(iae, e);
+ throw iae;
+ }
+
+ }
+
+
+ /**
+ * Add a new repository to the set of places this ClassLoader can look for
+ * classes to be loaded.
+ *
+ * @param repository Name of a source of classes to be loaded, such as a
+ * directory pathname, a JAR file pathname, or a ZIP file pathname
+ *
+ * @exception IllegalArgumentException if the specified repository is
+ * invalid or does not exist
+ */
+ synchronized void addRepository(String repository, File file) {
+
+ // Note : There should be only one (of course), but I think we should
+ // keep this a bit generic
+
+ if (repository == null)
+ return;
+
+ if (log.isDebugEnabled())
+ log.debug("addRepository(" + repository + ")");
+
+ int i;
+
+ // Add this repository to our internal list
+ String[] result = new String[repositories.length + 1];
+ for (i = 0; i < repositories.length; i++) {
+ result[i] = repositories[i];
+ }
+ result[repositories.length] = repository;
+ repositories = result;
+
+ // Add the file to the list
+ File[] result2 = new File[files.length + 1];
+ for (i = 0; i < files.length; i++) {
+ result2[i] = files[i];
+ }
+ result2[files.length] = file;
+ files = result2;
+
+ }
+
+
+ synchronized void addJar(String jar, JarFile jarFile, File file)
+ throws IOException {
+
+ if (jar == null)
+ return;
+ if (jarFile == null)
+ return;
+ if (file == null)
+ return;
+
+ if (log.isDebugEnabled())
+ log.debug("addJar(" + jar + ")");
+
+ int i;
+
+ if ((jarPath != null) && (jar.startsWith(jarPath))) {
+
+ String jarName = jar.substring(jarPath.length());
+ while (jarName.startsWith("/"))
+ jarName = jarName.substring(1);
+
+ String[] result = new String[jarNames.length + 1];
+ for (i = 0; i < jarNames.length; i++) {
+ result[i] = jarNames[i];
+ }
+ result[jarNames.length] = jarName;
+ jarNames = result;
+
+ }
+
+ try {
+
+ // Register the JAR for tracking
+
+ long lastModified =
+ ((ResourceAttributes) resources.getAttributes(jar))
+ .getLastModified();
+
+ String[] result = new String[paths.length + 1];
+ for (i = 0; i < paths.length; i++) {
+ result[i] = paths[i];
+ }
+ result[paths.length] = jar;
+ paths = result;
+
+ long[] result3 = new long[lastModifiedDates.length + 1];
+ for (i = 0; i < lastModifiedDates.length; i++) {
+ result3[i] = lastModifiedDates[i];
+ }
+ result3[lastModifiedDates.length] = lastModified;
+ lastModifiedDates = result3;
+
+ } catch (NamingException e) {
+ // Ignore
+ }
+
+ // If the JAR currently contains invalid classes, don't actually use it
+ // for classloading
+ if (!validateJarFile(file))
+ return;
+
+ JarFile[] result2 = new JarFile[jarFiles.length + 1];
+ for (i = 0; i < jarFiles.length; i++) {
+ result2[i] = jarFiles[i];
+ }
+ result2[jarFiles.length] = jarFile;
+ jarFiles = result2;
+
+ // Add the file to the list
+ File[] result4 = new File[jarRealFiles.length + 1];
+ for (i = 0; i < jarRealFiles.length; i++) {
+ result4[i] = jarRealFiles[i];
+ }
+ result4[jarRealFiles.length] = file;
+ jarRealFiles = result4;
+ }
+
+
+ /**
+ * Return a String array of the current repositories for this class
+ * loader. If there are no repositories, a zero-length array is
+ * returned.For security reason, returns a clone of the Array (since
+ * String are immutable).
+ */
+ public String[] findRepositories() {
+
+ return ((String[])repositories.clone());
+
+ }
+
+
+ /**
+ * Have one or more classes or resources been modified so that a reload
+ * is appropriate?
+ */
+ public boolean modified() {
+
+ if (log.isDebugEnabled())
+ log.debug("modified()");
+
+ // Checking for modified loaded resources
+ int length = paths.length;
+
+ // A rare race condition can occur in the updates of the two arrays
+ // It's totally ok if the latest class added is not checked (it will
+ // be checked the next time
+ int length2 = lastModifiedDates.length;
+ if (length > length2)
+ length = length2;
+
+ for (int i = 0; i < length; i++) {
+ try {
+ long lastModified =
+ ((ResourceAttributes) resources.getAttributes(paths[i]))
+ .getLastModified();
+ if (lastModified != lastModifiedDates[i]) {
+ if( log.isDebugEnabled() )
+ log.debug(" Resource '" + paths[i]
+ + "' was modified; Date is now: "
+ + new java.util.Date(lastModified) + " Was: "
+ + new java.util.Date(lastModifiedDates[i]));
+ return (true);
+ }
+ } catch (NamingException e) {
+ log.error(" Resource '" + paths[i] + "' is missing");
+ return (true);
+ }
+ }
+
+ length = jarNames.length;
+
+ // Check if JARs have been added or removed
+ if (getJarPath() != null) {
+
+ try {
+ NamingEnumeration enum_ = resources.listBindings(getJarPath());
+ int i = 0;
+ while (enum_.hasMoreElements() && (i < length)) {
+ NameClassPair ncPair = (NameClassPair) enum_.nextElement();
+ String name = ncPair.getName();
+ // Ignore non JARs present in the lib folder
+ if (!name.endsWith(".jar"))
+ continue;
+ if (!name.equals(jarNames[i])) {
+ // Missing JAR
+ log.info(" Additional JARs have been added : '"
+ + name + "'");
+ return (true);
+ }
+ i++;
+ }
+ if (enum_.hasMoreElements()) {
+ while (enum_.hasMoreElements()) {
+ NameClassPair ncPair =
+ (NameClassPair) enum_.nextElement();
+ String name = ncPair.getName();
+ // Additional non-JAR files are allowed
+ if (name.endsWith(".jar")) {
+ // There was more JARs
+ log.info(" Additional JARs have been added");
+ return (true);
+ }
+ }
+ } else if (i < jarNames.length) {
+ // There was less JARs
+ log.info(" Additional JARs have been added");
+ return (true);
+ }
+ } catch (NamingException e) {
+ if (log.isDebugEnabled())
+ log.debug(" Failed tracking modifications of '"
+ + getJarPath() + "'");
+ } catch (ClassCastException e) {
+ log.error(" Failed tracking modifications of '"
+ + getJarPath() + "' : " + e.getMessage());
+ }
+
+ }
+
+ // No classes have been modified
+ return (false);
+
+ }
+
+
+ /**
+ * Render a String representation of this object.
+ */
+ public String toString() {
+
+ StringBuffer sb = new StringBuffer("WebappClassLoader\r\n");
+ sb.append(" delegate: ");
+ sb.append(delegate);
+ sb.append("\r\n");
+ sb.append(" repositories:\r\n");
+ if (repositories != null) {
+ for (int i = 0; i < repositories.length; i++) {
+ sb.append(" ");
+ sb.append(repositories[i]);
+ sb.append("\r\n");
+ }
+ }
+ if (this.parent != null) {
+ sb.append("----------> Parent Classloader:\r\n");
+ sb.append(this.parent.toString());
+ sb.append("\r\n");
+ }
+ return (sb.toString());
+
+ }
+
+
+ // ---------------------------------------------------- ClassLoader Methods
+
+
+ /**
+ * Add the specified URL to the classloader.
+ */
+ protected void addURL(URL url) {
+ super.addURL(url);
+ hasExternalRepositories = true;
+ repositoryURLs = null;
+ }
+
+
+ /**
+ * Find the specified class in our local repositories, if possible. If
+ * not found, throw <code>ClassNotFoundException</code>.
+ *
+ * @param name Name of the class to be loaded
+ *
+ * @exception ClassNotFoundException if the class was not found
+ */
+ public Class findClass(String name) throws ClassNotFoundException {
+
+ if (log.isDebugEnabled())
+ log.debug(" findClass(" + name + ")");
+
+ // (1) Permission to define this class when using a SecurityManager
+ if (securityManager != null) {
+ int i = name.lastIndexOf('.');
+ if (i >= 0) {
+ try {
+ if (log.isTraceEnabled())
+ log.trace(" securityManager.checkPackageDefinition");
+ securityManager.checkPackageDefinition(name.substring(0,i));
+ } catch (Exception se) {
+ if (log.isTraceEnabled())
+ log.trace(" -->Exception-->ClassNotFoundException", se);
+ throw new ClassNotFoundException(name, se);
+ }
+ }
+ }
+
+ // Ask our superclass to locate this class, if possible
+ // (throws ClassNotFoundException if it is not found)
+ Class clazz = null;
+ try {
+ if (log.isTraceEnabled())
+ log.trace(" findClassInternal(" + name + ")");
+ try {
+ clazz = findClassInternal(name);
+ } catch(ClassNotFoundException cnfe) {
+ if (!hasExternalRepositories) {
+ throw cnfe;
+ }
+ } catch(AccessControlException ace) {
+ throw new ClassNotFoundException(name, ace);
+ } catch (RuntimeException e) {
+ if (log.isTraceEnabled())
+ log.trace(" -->RuntimeException Rethrown", e);
+ throw e;
+ }
+ if ((clazz == null) && hasExternalRepositories) {
+ try {
+ clazz = super.findClass(name);
+ } catch(AccessControlException ace) {
+ throw new ClassNotFoundException(name, ace);
+ } catch (RuntimeException e) {
+ if (log.isTraceEnabled())
+ log.trace(" -->RuntimeException Rethrown", e);
+ throw e;
+ }
+ }
+ if (clazz == null) {
+ if (log.isDebugEnabled())
+ log.debug(" --> Returning ClassNotFoundException");
+ throw new ClassNotFoundException(name);
+ }
+ } catch (ClassNotFoundException e) {
+ if (log.isTraceEnabled())
+ log.trace(" --> Passing on ClassNotFoundException");
+ throw e;
+ }
+
+ // Return the class we have located
+ if (log.isTraceEnabled())
+ log.debug(" Returning class " + clazz);
+ if ((log.isTraceEnabled()) && (clazz != null))
+ log.debug(" Loaded by " + clazz.getClassLoader());
+ return (clazz);
+
+ }
+
+
+ /**
+ * Find the specified resource in our local repository, and return a
+ * <code>URL</code> refering to it, or <code>null</code> if this resource
+ * cannot be found.
+ *
+ * @param name Name of the resource to be found
+ */
+ public URL findResource(final String name) {
+
+ if (log.isDebugEnabled())
+ log.debug(" findResource(" + name + ")");
+
+ URL url = null;
+
+ ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
+ if (entry == null) {
+ entry = findResourceInternal(name, name);
+ }
+ if (entry != null) {
+ url = entry.source;
+ }
+
+ if ((url == null) && hasExternalRepositories)
+ url = super.findResource(name);
+
+ if (log.isDebugEnabled()) {
+ if (url != null)
+ log.debug(" --> Returning '" + url.toString() + "'");
+ else
+ log.debug(" --> Resource not found, returning null");
+ }
+ return (url);
+
+ }
+
+
+ /**
+ * Return an enumeration of <code>URLs</code> representing all of the
+ * resources with the given name. If no resources with this name are
+ * found, return an empty enumeration.
+ *
+ * @param name Name of the resources to be found
+ *
+ * @exception IOException if an input/output error occurs
+ */
+ public Enumeration findResources(String name) throws IOException {
+
+ if (log.isDebugEnabled())
+ log.debug(" findResources(" + name + ")");
+
+ Vector result = new Vector();
+
+ int jarFilesLength = jarFiles.length;
+ int repositoriesLength = repositories.length;
+
+ int i;
+
+ // Looking at the repositories
+ for (i = 0; i < repositoriesLength; i++) {
+ try {
+ String fullPath = repositories[i] + name;
+ resources.lookup(fullPath);
+ // Note : Not getting an exception here means the resource was
+ // found
+ try {
+ result.addElement(getURI(new File(files[i], name)));
+ } catch (MalformedURLException e) {
+ // Ignore
+ }
+ } catch (NamingException e) {
+ }
+ }
+
+ // Looking at the JAR files
+ synchronized (jarFiles) {
+ openJARs();
+ for (i = 0; i < jarFilesLength; i++) {
+ JarEntry jarEntry = jarFiles[i].getJarEntry(name);
+ if (jarEntry != null) {
+ try {
+ String jarFakeUrl = getURI(jarRealFiles[i]).toString();
+ jarFakeUrl = "jar:" + jarFakeUrl + "!/" + name;
+ result.addElement(new URL(jarFakeUrl));
+ } catch (MalformedURLException e) {
+ // Ignore
+ }
+ }
+ }
+ }
+
+ // Adding the results of a call to the superclass
+ if (hasExternalRepositories) {
+
+ Enumeration otherResourcePaths = super.findResources(name);
+
+ while (otherResourcePaths.hasMoreElements()) {
+ result.addElement(otherResourcePaths.nextElement());
+ }
+
+ }
+
+ return result.elements();
+
+ }
+
+
+ /**
+ * Find the resource with the given name. A resource is some data
+ * (images, audio, text, etc.) that can be accessed by class code in a
+ * way that is independent of the location of the code. The name of a
+ * resource is a "/"-separated path name that identifies the resource.
+ * If the resource cannot be found, return <code>null</code>.
+ * <p>
+ * This method searches according to the following algorithm, returning
+ * as soon as it finds the appropriate URL. If the resource cannot be
+ * found, returns <code>null</code>.
+ * <ul>
+ * <li>If the <code>delegate</code> property is set to <code>true</code>,
+ * call the <code>getResource()</code> method of the parent class
+ * loader, if any.</li>
+ * <li>Call <code>findResource()</code> to find this resource in our
+ * locally defined repositories.</li>
+ * <li>Call the <code>getResource()</code> method of the parent class
+ * loader, if any.</li>
+ * </ul>
+ *
+ * @param name Name of the resource to return a URL for
+ */
+ public URL getResource(String name) {
+
+ if (log.isDebugEnabled())
+ log.debug("getResource(" + name + ")");
+ URL url = null;
+
+ // (1) Delegate to parent if requested
+ if (delegate) {
+ if (log.isDebugEnabled())
+ log.debug(" Delegating to parent classloader " + parent);
+ ClassLoader loader = parent;
+ if (loader == null)
+ loader = system;
+ url = loader.getResource(name);
+ if (url != null) {
+ if (log.isDebugEnabled())
+ log.debug(" --> Returning '" + url.toString() + "'");
+ return (url);
+ }
+ }
+
+ // (2) Search local repositories
+ url = findResource(name);
+ if (url != null) {
+ // Locating the repository for special handling in the case
+ // of a JAR
+ ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
+ try {
+ String repository = entry.codeBase.toString();
+ if ((repository.endsWith(".jar"))
+ && (!(name.endsWith(".class")))) {
+ // Copy binary content to the work directory if not present
+ File resourceFile = new File(loaderDir, name);
+ url = resourceFile.toURL();
+ }
+ } catch (Exception e) {
+ // Ignore
+ }
+ if (log.isDebugEnabled())
+ log.debug(" --> Returning '" + url.toString() + "'");
+ return (url);
+ }
+
+ // (3) Delegate to parent unconditionally if not already attempted
+ if( !delegate ) {
+ ClassLoader loader = parent;
+ if (loader == null)
+ loader = system;
+ url = loader.getResource(name);
+ if (url != null) {
+ if (log.isDebugEnabled())
+ log.debug(" --> Returning '" + url.toString() + "'");
+ return (url);
+ }
+ }
+
+ // (4) Resource was not found
+ if (log.isDebugEnabled())
+ log.debug(" --> Resource not found, returning null");
+ return (null);
+
+ }
+
+
+ /**
+ * Find the resource with the given name, and return an input stream
+ * that can be used for reading it. The search order is as described
+ * for <code>getResource()</code>, after checking to see if the resource
+ * data has been previously cached. If the resource cannot be found,
+ * return <code>null</code>.
+ *
+ * @param name Name of the resource to return an input stream for
+ */
+ public InputStream getResourceAsStream(String name) {
+
+ if (log.isDebugEnabled())
+ log.debug("getResourceAsStream(" + name + ")");
+ InputStream stream = null;
+
+ // (0) Check for a cached copy of this resource
+ stream = findLoadedResource(name);
+ if (stream != null) {
+ if (log.isDebugEnabled())
+ log.debug(" --> Returning stream from cache");
+ return (stream);
+ }
+
+ // (1) Delegate to parent if requested
+ if (delegate) {
+ if (log.isDebugEnabled())
+ log.debug(" Delegating to parent classloader " + parent);
+ ClassLoader loader = parent;
+ if (loader == null)
+ loader = system;
+ stream = loader.getResourceAsStream(name);
+ if (stream != null) {
+ // FIXME - cache???
+ if (log.isDebugEnabled())
+ log.debug(" --> Returning stream from parent");
+ return (stream);
+ }
+ }
+
+ // (2) Search local repositories
+ if (log.isDebugEnabled())
+ log.debug(" Searching local repositories");
+ URL url = findResource(name);
+ if (url != null) {
+ // FIXME - cache???
+ if (log.isDebugEnabled())
+ log.debug(" --> Returning stream from local");
+ stream = findLoadedResource(name);
+ try {
+ if (hasExternalRepositories && (stream == null))
+ stream = url.openStream();
+ } catch (IOException e) {
+ ; // Ignore
+ }
+ if (stream != null)
+ return (stream);
+ }
+
+ // (3) Delegate to parent unconditionally
+ if (!delegate) {
+ if (log.isDebugEnabled())
+ log.debug(" Delegating to parent classloader unconditionally " + parent);
+ ClassLoader loader = parent;
+ if (loader == null)
+ loader = system;
+ stream = loader.getResourceAsStream(name);
+ if (stream != null) {
+ // FIXME - cache???
+ if (log.isDebugEnabled())
+ log.debug(" --> Returning stream from parent");
+ return (stream);
+ }
+ }
+
+ // (4) Resource was not found
+ if (log.isDebugEnabled())
+ log.debug(" --> Resource not found, returning null");
+ return (null);
+
+ }
+
+
+ /**
+ * Load the class with the specified name. This method searches for
+ * classes in the same manner as <code>loadClass(String, boolean)</code>
+ * with <code>false</code> as the second argument.
+ *
+ * @param name Name of the class to be loaded
+ *
+ * @exception ClassNotFoundException if the class was not found
+ */
+ public Class loadClass(String name) throws ClassNotFoundException {
+
+ return (loadClass(name, false));
+
+ }
+
+
+ /**
+ * Load the class with the specified name, searching using the following
+ * algorithm until it finds and returns the class. If the class cannot
+ * be found, returns <code>ClassNotFoundException</code>.
+ * <ul>
+ * <li>Call <code>findLoadedClass(String)</code> to check if the
+ * class has already been loaded. If it has, the same
+ * <code>Class</code> object is returned.</li>
+ * <li>If the <code>delegate</code> property is set to <code>true</code>,
+ * call the <code>loadClass()</code> method of the parent class
+ * loader, if any.</li>
+ * <li>Call <code>findClass()</code> to find this class in our locally
+ * defined repositories.</li>
+ * <li>Call the <code>loadClass()</code> method of our parent
+ * class loader, if any.</li>
+ * </ul>
+ * If the class was found using the above steps, and the
+ * <code>resolve</code> flag is <code>true</code>, this method will then
+ * call <code>resolveClass(Class)</code> on the resulting Class object.
+ *
+ * @param name Name of the class to be loaded
+ * @param resolve If <code>true</code> then resolve the class
+ *
+ * @exception ClassNotFoundException if the class was not found
+ */
+ public Class loadClass(String name, boolean resolve)
+ throws ClassNotFoundException {
+
+ if (log.isDebugEnabled())
+ log.debug("loadClass(" + name + ", " + resolve + ")");
+ Class clazz = null;
+
+ // Don't load classes if class loader is stopped
+ if (!started) {
+ log.info(sm.getString("webappClassLoader.stopped"));
+ throw new ThreadDeath();
+ }
+
+ // (0) Check our previously loaded local class cache
+ clazz = findLoadedClass0(name);
+ if (clazz != null) {
+ if (log.isDebugEnabled())
+ log.debug(" Returning class from cache");
+ if (resolve)
+ resolveClass(clazz);
+ return (clazz);
+ }
+
+ // (0.1) Check our previously loaded class cache
+ clazz = findLoadedClass(name);
+ if (clazz != null) {
+ if (log.isDebugEnabled())
+ log.debug(" Returning class from cache");
+ if (resolve)
+ resolveClass(clazz);
+ return (clazz);
+ }
+
+ // (0.2) Try loading the class with the system class loader, to prevent
+ // the webapp from overriding J2SE classes
+ // GOOGLE: use the bootstrap loader, not the system loader; it breaks
+ // embedding.
+ try {
+ // clazz = system.loadClass(name);
+ clazz = Class.forName(name, false, null);
+ if (clazz != null) {
+ if (resolve)
+ resolveClass(clazz);
+ return (clazz);
+ }
+ } catch (ClassNotFoundException e) {
+ // Ignore
+ }
+
+ // (0.5) Permission to access this class when using a SecurityManager
+ if (securityManager != null) {
+ int i = name.lastIndexOf('.');
+ if (i >= 0) {
+ try {
+ securityManager.checkPackageAccess(name.substring(0,i));
+ } catch (SecurityException se) {
+ String error = "Security Violation, attempt to use " +
+ "Restricted Class: " + name;
+ log.info(error, se);
+ throw new ClassNotFoundException(error, se);
+ }
+ }
+ }
+
+ boolean delegateLoad = delegate || filter(name);
+
+ // (1) Delegate to our parent if requested
+ if (delegateLoad) {
+ if (log.isDebugEnabled())
+ log.debug(" Delegating to parent classloader1 " + parent);
+ ClassLoader loader = parent;
+ if (loader == null)
+ loader = system;
+ try {
+ clazz = loader.loadClass(name);
+ if (clazz != null) {
+ if (log.isDebugEnabled())
+ log.debug(" Loading class from parent");
+ if (resolve)
+ resolveClass(clazz);
+ return (clazz);
+ }
+ } catch (ClassNotFoundException e) {
+ ;
+ }
+ }
+
+ // (2) Search local repositories
+ if (log.isDebugEnabled())
+ log.debug(" Searching local repositories");
+ try {
+ clazz = findClass(name);
+ if (clazz != null) {
+ if (log.isDebugEnabled())
+ log.debug(" Loading class from local repository");
+ if (resolve)
+ resolveClass(clazz);
+ return (clazz);
+ }
+ } catch (ClassNotFoundException e) {
+ ;
+ }
+
+ // (3) Delegate to parent unconditionally
+ if (!delegateLoad) {
+ if (log.isDebugEnabled())
+ log.debug(" Delegating to parent classloader at end: " + parent);
+ ClassLoader loader = parent;
+ if (loader == null)
+ loader = system;
+ try {
+ clazz = loader.loadClass(name);
+ if (clazz != null) {
+ if (log.isDebugEnabled())
+ log.debug(" Loading class from parent");
+ if (resolve)
+ resolveClass(clazz);
+ return (clazz);
+ }
+ } catch (ClassNotFoundException e) {
+ ;
+ }
+ }
+
+ throw new ClassNotFoundException(name);
+ }
+
+
+ /**
+ * Get the Permissions for a CodeSource. If this instance
+ * of WebappClassLoader is for a web application context,
+ * add read FilePermission or JndiPermissions for the base
+ * directory (if unpacked),
+ * the context URL, and jar file resources.
+ *
+ * @param codeSource where the code was loaded from
+ * @return PermissionCollection for CodeSource
+ */
+ protected PermissionCollection getPermissions(CodeSource codeSource) {
+
+ String codeUrl = codeSource.getLocation().toString();
+ PermissionCollection pc;
+ if ((pc = (PermissionCollection)loaderPC.get(codeUrl)) == null) {
+ pc = super.getPermissions(codeSource);
+ if (pc != null) {
+ Iterator perms = permissionList.iterator();
+ while (perms.hasNext()) {
+ Permission p = (Permission)perms.next();
+ pc.add(p);
+ }
+ loaderPC.put(codeUrl,pc);
+ }
+ }
+ return (pc);
+
+ }
+
+
+ /**
+ * Returns the search path of URLs for loading classes and resources.
+ * This includes the original list of URLs specified to the constructor,
+ * along with any URLs subsequently appended by the addURL() method.
+ * @return the search path of URLs for loading classes and resources.
+ */
+ public URL[] getURLs() {
+
+ if (repositoryURLs != null) {
+ return repositoryURLs;
+ }
+
+ URL[] external = super.getURLs();
+
+ int filesLength = files.length;
+ int jarFilesLength = jarRealFiles.length;
+ int length = filesLength + jarFilesLength + external.length;
+ int i;
+
+ try {
+
+ URL[] urls = new URL[length];
+ for (i = 0; i < length; i++) {
+ if (i < filesLength) {
+ urls[i] = getURL(files[i]);
+ } else if (i < filesLength + jarFilesLength) {
+ urls[i] = getURL(jarRealFiles[i - filesLength]);
+ } else {
+ urls[i] = external[i - filesLength - jarFilesLength];
+ }
+ }
+
+ repositoryURLs = urls;
+
+ } catch (MalformedURLException e) {
+ repositoryURLs = new URL[0];
+ }
+
+ return repositoryURLs;
+
+ }
+
+
+ // ------------------------------------------------------ Lifecycle Methods
+
+
+ /**
+ * Add a lifecycle event listener to this component.
+ *
+ * @param listener The listener to add
+ */
+ public void addLifecycleListener(LifecycleListener listener) {
+ }
+
+
+ /**
+ * Get the lifecycle listeners associated with this lifecycle. If this
+ * Lifecycle has no listeners registered, a zero-length array is returned.
+ */
+ public LifecycleListener[] findLifecycleListeners() {
+ return new LifecycleListener[0];
+ }
+
+
+ /**
+ * Remove a lifecycle event listener from this component.
+ *
+ * @param listener The listener to remove
+ */
+ public void removeLifecycleListener(LifecycleListener listener) {
+ }
+
+
+ /**
+ * Start the class loader.
+ *
+ * @exception LifecycleException if a lifecycle error occurs
+ */
+ public void start() throws LifecycleException {
+
+ started = true;
+
+ }
+
+
+ /**
+ * Stop the class loader.
+ *
+ * @exception LifecycleException if a lifecycle error occurs
+ */
+ public void stop() throws LifecycleException {
+
+ started = false;
+
+ int length = files.length;
+ for (int i = 0; i < length; i++) {
+ files[i] = null;
+ }
+
+ length = jarFiles.length;
+ for (int i = 0; i < length; i++) {
+ try {
+ if (jarFiles[i] != null) {
+ jarFiles[i].close();
+ }
+ } catch (IOException e) {
+ // Ignore
+ }
+ jarFiles[i] = null;
+ }
+
+ notFoundResources.clear();
+ resourceEntries.clear();
+ resources = null;
+ repositories = null;
+ repositoryURLs = null;
+ files = null;
+ jarFiles = null;
+ jarRealFiles = null;
+ jarPath = null;
+ jarNames = null;
+ lastModifiedDates = null;
+ paths = null;
+ hasExternalRepositories = false;
+ parent = null;
+
+ permissionList.clear();
+ loaderPC.clear();
+
+ if (loaderDir != null) {
+ deleteDir(loaderDir);
+ }
+
+ org.apache.commons.logging.LogFactory.release(this);
+
+ }
+
+
+ /**
+ * Used to periodically signal to the classloader to release
+ * JAR resources.
+ */
+ public void closeJARs(boolean force) {
+ if (jarFiles.length > 0) {
+ try {
+ synchronized (jarFiles) {
+ if (force || (System.currentTimeMillis()
+ > (lastJarAccessed + 90000))) {
+ for (int i = 0; i < jarFiles.length; i++) {
+ if (jarFiles[i] != null) {
+ jarFiles[i].close();
+ jarFiles[i] = null;
+ }
+ }
+ }
+ }
+ } catch (IOException e) {
+ log("Failed to close JAR", e);
+ }
+ }
+ }
+
+
+ // ------------------------------------------------------ Protected Methods
+
+
+ /**
+ * Used to periodically signal to the classloader to release JAR resources.
+ */
+ protected void openJARs() {
+ if (started && (jarFiles.length > 0)) {
+ lastJarAccessed = System.currentTimeMillis();
+ if (jarFiles[0] == null) {
+ try {
+ for (int i = 0; i < jarFiles.length; i++) {
+ jarFiles[i] = new JarFile(jarRealFiles[i]);
+ }
+ } catch (IOException e) {
+ log("Failed to open JAR", e);
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Find specified class in local repositories.
+ *
+ * @return the loaded class, or null if the class isn't found
+ */
+ protected Class findClassInternal(String name)
+ throws ClassNotFoundException {
+
+ if (!validate(name))
+ throw new ClassNotFoundException(name);
+
+ String tempPath = name.replace('.', '/');
+ String classPath = tempPath + ".class";
+
+ ResourceEntry entry = null;
+
+ entry = findResourceInternal(name, classPath);
+
+ if ((entry == null) || (entry.binaryContent == null))
+ throw new ClassNotFoundException(name);
+
+ Class clazz = entry.loadedClass;
+ if (clazz != null)
+ return clazz;
+
+ // Looking up the package
+ String packageName = null;
+ int pos = name.lastIndexOf('.');
+ if (pos != -1)
+ packageName = name.substring(0, pos);
+
+ Package pkg = null;
+
+ if (packageName != null) {
+
+ pkg = getPackage(packageName);
+
+ // Define the package (if null)
+ if (pkg == null) {
+ if (entry.manifest == null) {
+ definePackage(packageName, null, null, null, null, null,
+ null, null);
+ } else {
+ definePackage(packageName, entry.manifest, entry.codeBase);
+ }
+ }
+
+ }
+
+ // Create the code source object
+ CodeSource codeSource =
+ new CodeSource(entry.codeBase, entry.certificates);
+
+ if (securityManager != null) {
+
+ // Checking sealing
+ if (pkg != null) {
+ boolean sealCheck = true;
+ if (pkg.isSealed()) {
+ sealCheck = pkg.isSealed(entry.codeBase);
+ } else {
+ sealCheck = (entry.manifest == null)
+ || !isPackageSealed(packageName, entry.manifest);
+ }
+ if (!sealCheck)
+ throw new SecurityException
+ ("Sealing violation loading " + name + " : Package "
+ + packageName + " is sealed.");
+ }
+
+ }
+
+ if (entry.loadedClass == null) {
+ synchronized (this) {
+ if (entry.loadedClass == null) {
+ clazz = defineClass(name, entry.binaryContent, 0,
+ entry.binaryContent.length,
+ codeSource);
+ entry.loadedClass = clazz;
+ entry.binaryContent = null;
+ entry.source = null;
+ entry.codeBase = null;
+ entry.manifest = null;
+ entry.certificates = null;
+ } else {
+ clazz = entry.loadedClass;
+ }
+ }
+ } else {
+ clazz = entry.loadedClass;
+ }
+
+ return clazz;
+
+ }
+
+ /**
+ * Find specified resource in local repositories. This block
+ * will execute under an AccessControl.doPrivilege block.
+ *
+ * @return the loaded resource, or null if the resource isn't found
+ */
+ private ResourceEntry findResourceInternal(File file, String path){
+ ResourceEntry entry = new ResourceEntry();
+ try {
+ entry.source = getURI(new File(file, path));
+ entry.codeBase = getURL(new File(file, path));
+ } catch (MalformedURLException e) {
+ return null;
+ }
+ return entry;
+ }
+
+
+ /**
+ * Find specified resource in local repositories.
+ *
+ * @return the loaded resource, or null if the resource isn't found
+ */
+ protected ResourceEntry findResourceInternal(String name, String path) {
+
+ if (!started) {
+ log.info(sm.getString("webappClassLoader.stopped"));
+ return null;
+ }
+
+ if ((name == null) || (path == null))
+ return null;
+
+ ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
+ if (entry != null)
+ return entry;
+
+ int contentLength = -1;
+ InputStream binaryStream = null;
+
+ int jarFilesLength = jarFiles.length;
+ int repositoriesLength = repositories.length;
+
+ int i;
+
+ Resource resource = null;
+
+ for (i = 0; (entry == null) && (i < repositoriesLength); i++) {
+ try {
+
+ String fullPath = repositories[i] + path;
+
+ Object lookupResult = resources.lookup(fullPath);
+ if (lookupResult instanceof Resource) {
+ resource = (Resource) lookupResult;
+ }
+
+ // Note : Not getting an exception here means the resource was
+ // found
+ if (securityManager != null) {
+ PrivilegedAction dp =
+ new PrivilegedFindResource(files[i], path);
+ entry = (ResourceEntry)AccessController.doPrivileged(dp);
+ } else {
+ entry = findResourceInternal(files[i], path);
+ }
+
+ ResourceAttributes attributes =
+ (ResourceAttributes) resources.getAttributes(fullPath);
+ contentLength = (int) attributes.getContentLength();
+ entry.lastModified = attributes.getLastModified();
+
+ if (resource != null) {
+
+ try {
+ binaryStream = resource.streamContent();
+ } catch (IOException e) {
+ return null;
+ }
+
+ // Register the full path for modification checking
+ // Note: Only syncing on a 'constant' object is needed
+ synchronized (allPermission) {
+
+ int j;
+
+ long[] result2 =
+ new long[lastModifiedDates.length + 1];
+ for (j = 0; j < lastModifiedDates.length; j++) {
+ result2[j] = lastModifiedDates[j];
+ }
+ result2[lastModifiedDates.length] = entry.lastModified;
+ lastModifiedDates = result2;
+
+ String[] result = new String[paths.length + 1];
+ for (j = 0; j < paths.length; j++) {
+ result[j] = paths[j];
+ }
+ result[paths.length] = fullPath;
+ paths = result;
+
+ }
+
+ }
+
+ } catch (NamingException e) {
+ }
+ }
+
+ if ((entry == null) && (notFoundResources.containsKey(name)))
+ return null;
+
+ JarEntry jarEntry = null;
+
+ synchronized (jarFiles) {
+
+ openJARs();
+ for (i = 0; (entry == null) && (i < jarFilesLength); i++) {
+
+ jarEntry = jarFiles[i].getJarEntry(path);
+
+ if (jarEntry != null) {
+
+ entry = new ResourceEntry();
+ try {
+ entry.codeBase = getURL(jarRealFiles[i]);
+ String jarFakeUrl = getURI(jarRealFiles[i]).toString();
+ jarFakeUrl = "jar:" + jarFakeUrl + "!/" + path;
+ entry.source = new URL(jarFakeUrl);
+ entry.lastModified = jarRealFiles[i].lastModified();
+ } catch (MalformedURLException e) {
+ return null;
+ }
+ contentLength = (int) jarEntry.getSize();
+ try {
+ entry.manifest = jarFiles[i].getManifest();
+ binaryStream = jarFiles[i].getInputStream(jarEntry);
+ } catch (IOException e) {
+ return null;
+ }
+
+ // Extract resources contained in JAR to the workdir
+ if (!(path.endsWith(".class"))) {
+ byte[] buf = new byte[1024];
+ File resourceFile = new File
+ (loaderDir, jarEntry.getName());
+ if (!resourceFile.exists()) {
+ Enumeration entries = jarFiles[i].entries();
+ while (entries.hasMoreElements()) {
+ JarEntry jarEntry2 =
+ (JarEntry) entries.nextElement();
+ if (!(jarEntry2.isDirectory())
+ && (!jarEntry2.getName().endsWith
+ (".class"))) {
+ resourceFile = new File
+ (loaderDir, jarEntry2.getName());
+ // No need to check mkdirs result because an
+ // IOException will occur anyway
+ resourceFile.getParentFile().mkdirs();
+ FileOutputStream os = null;
+ InputStream is = null;
+ try {
+ is = jarFiles[i].getInputStream
+ (jarEntry2);
+ os = new FileOutputStream
+ (resourceFile);
+ while (true) {
+ int n = is.read(buf);
+ if (n <= 0) {
+ break;
+ }
+ os.write(buf, 0, n);
+ }
+ } catch (IOException e) {
+ // Ignore
+ } finally {
+ try {
+ if (is != null) {
+ is.close();
+ }
+ } catch (IOException e) {
+ }
+ try {
+ if (os != null) {
+ os.close();
+ }
+ } catch (IOException e) {
+ }
+ }
+ }
+ }
+ }
+ }
+
+ }
+
+ }
+
+ if (entry == null) {
+ synchronized (notFoundResources) {
+ notFoundResources.put(name, name);
+ }
+ return null;
+ }
+
+ if (binaryStream != null) {
+
+ byte[] binaryContent = new byte[contentLength];
+
+ try {
+ int pos = 0;
+
+ while (true) {
+ int n = binaryStream.read(binaryContent, pos,
+ binaryContent.length - pos);
+ if (n <= 0)
+ break;
+ pos += n;
+ }
+ binaryStream.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ return null;
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ entry.binaryContent = binaryContent;
+
+ // The certificates are only available after the JarEntry
+ // associated input stream has been fully read
+ if (jarEntry != null) {
+ entry.certificates = jarEntry.getCertificates();
+ }
+
+ }
+
+ }
+
+ // Add the entry in the local resource repository
+ synchronized (resourceEntries) {
+ // Ensures that all the threads which may be in a race to load
+ // a particular class all end up with the same ResourceEntry
+ // instance
+ ResourceEntry entry2 = (ResourceEntry) resourceEntries.get(name);
+ if (entry2 == null) {
+ resourceEntries.put(name, entry);
+ } else {
+ entry = entry2;
+ }
+ }
+
+ return entry;
+
+ }
+
+
+ /**
+ * Returns true if the specified package name is sealed according to the
+ * given manifest.
+ */
+ protected boolean isPackageSealed(String name, Manifest man) {
+
+ String path = name + "/";
+ Attributes attr = man.getAttributes(path);
+ String sealed = null;
+ if (attr != null) {
+ sealed = attr.getValue(Name.SEALED);
+ }
+ if (sealed == null) {
+ if ((attr = man.getMainAttributes()) != null) {
+ sealed = attr.getValue(Name.SEALED);
+ }
+ }
+ return "true".equalsIgnoreCase(sealed);
+
+ }
+
+
+ /**
+ * Finds the resource with the given name if it has previously been
+ * loaded and cached by this class loader, and return an input stream
+ * to the resource data. If this resource has not been cached, return
+ * <code>null</code>.
+ *
+ * @param name Name of the resource to return
+ */
+ protected InputStream findLoadedResource(String name) {
+
+ ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
+ if (entry != null) {
+ if (entry.binaryContent != null)
+ return new ByteArrayInputStream(entry.binaryContent);
+ }
+ return (null);
+
+ }
+
+
+ /**
+ * Finds the class with the given name if it has previously been
+ * loaded and cached by this class loader, and return the Class object.
+ * If this class has not been cached, return <code>null</code>.
+ *
+ * @param name Name of the resource to return
+ */
+ protected Class findLoadedClass0(String name) {
+
+ ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
+ if (entry != null) {
+ return entry.loadedClass;
+ }
+ return (null); // FIXME - findLoadedResource()
+
+ }
+
+
+ /**
+ * Refresh the system policy file, to pick up eventual changes.
+ */
+ protected void refreshPolicy() {
+
+ try {
+ // The policy file may have been modified to adjust
+ // permissions, so we're reloading it when loading or
+ // reloading a Context
+ Policy policy = Policy.getPolicy();
+ policy.refresh();
+ } catch (AccessControlException e) {
+ // Some policy files may restrict this, even for the core,
+ // so this exception is ignored
+ }
+
+ }
+
+
+ /**
+ * Filter classes.
+ *
+ * @param name class name
+ * @return true if the class should be filtered
+ */
+ protected boolean filter(String name) {
+
+ if (name == null)
+ return false;
+
+ // Looking up the package
+ String packageName = null;
+ int pos = name.lastIndexOf('.');
+ if (pos != -1)
+ packageName = name.substring(0, pos);
+ else
+ return false;
+
+ for (int i = 0; i < packageTriggers.length; i++) {
+ if (packageName.startsWith(packageTriggers[i]))
+ return true;
+ }
+
+ return false;
+
+ }
+
+
+ /**
+ * Validate a classname. As per SRV.9.7.2, we must restict loading of
+ * classes from J2SE (java.*) and classes of the servlet API
+ * (javax.servlet.*). That should enhance robustness and prevent a number
+ * of user error (where an older version of servlet.jar would be present
+ * in /WEB-INF/lib).
+ *
+ * @param name class name
+ * @return true if the name is valid
+ */
+ protected boolean validate(String name) {
+
+ if (name == null)
+ return false;
+ if (name.startsWith("java."))
+ return false;
+
+ return true;
+
+ }
+
+
+ /**
+ * Check the specified JAR file, and return <code>true</code> if it does
+ * not contain any of the trigger classes.
+ *
+ * @param jarfile The JAR file to be checked
+ *
+ * @exception IOException if an input/output error occurs
+ */
+ private boolean validateJarFile(File jarfile)
+ throws IOException {
+
+ if (triggers == null)
+ return (true);
+ JarFile jarFile = new JarFile(jarfile);
+ for (int i = 0; i < triggers.length; i++) {
+ Class clazz = null;
+ try {
+ if (parent != null) {
+ clazz = parent.loadClass(triggers[i]);
+ } else {
+ clazz = Class.forName(triggers[i]);
+ }
+ } catch (Throwable t) {
+ clazz = null;
+ }
+ if (clazz == null)
+ continue;
+ String name = triggers[i].replace('.', '/') + ".class";
+ if (log.isDebugEnabled())
+ log.debug(" Checking for " + name);
+ JarEntry jarEntry = jarFile.getJarEntry(name);
+ if (jarEntry != null) {
+ log.info("validateJarFile(" + jarfile +
+ ") - jar not loaded. See Servlet Spec 2.3, "
+ + "section 9.7.2. Offending class: " + name);
+ jarFile.close();
+ return (false);
+ }
+ }
+ jarFile.close();
+ return (true);
+
+ }
+
+
+ /**
+ * Get URL.
+ */
+ protected URL getURL(File file)
+ throws MalformedURLException {
+
+ File realFile = file;
+ try {
+ realFile = realFile.getCanonicalFile();
+ } catch (IOException e) {
+ // Ignore
+ }
+ return realFile.toURL();
+
+ }
+
+
+ /**
+ * Get URL.
+ */
+ protected URL getURI(File file)
+ throws MalformedURLException {
+
+ return jdkCompat.getURI(file);
+
+ }
+
+
+ /**
+ * Delete the specified directory, including all of its contents and
+ * subdirectories recursively.
+ *
+ * @param dir File object representing the directory to be deleted
+ */
+ protected static void deleteDir(File dir) {
+
+ String files[] = dir.list();
+ if (files == null) {
+ files = new String[0];
+ }
+ for (int i = 0; i < files.length; i++) {
+ File file = new File(dir, files[i]);
+ if (file.isDirectory()) {
+ deleteDir(file);
+ } else {
+ file.delete();
+ }
+ }
+ dir.delete();
+
+ }
+
+
+ /**
+ * Log a debugging output message.
+ *
+ * @param message Message to be logged
+ */
+ private void log(String message) {
+
+ System.out.println("WebappClassLoader: " + message);
+
+ }
+
+
+ /**
+ * Log a debugging output message with an exception.
+ *
+ * @param message Message to be logged
+ * @param throwable Exception to be logged
+ */
+ private void log(String message, Throwable throwable) {
+
+ System.out.println("WebappClassLoader: " + message);
+ throwable.printStackTrace(System.out);
+
+ }
+
+}
diff --git a/dev/core/test/com/google/gwt/dev/GWTCompilerTest.java b/dev/core/test/com/google/gwt/dev/GWTCompilerTest.java
new file mode 100644
index 0000000..8955714
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/GWTCompilerTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009 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;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.dev.GWTCompiler.GWTCompilerOptionsImpl;
+import com.google.gwt.dev.jjs.JsOutputOption;
+
+import java.io.File;
+
+/**
+ * Test for deprecated {@link GWTShell}.
+ */
+@SuppressWarnings("deprecation")
+public class GWTCompilerTest extends ArgProcessorTestBase {
+
+ private final GWTCompiler.ArgProcessor argProcessor;
+ private final GWTCompilerOptionsImpl options = new GWTCompilerOptionsImpl();
+
+ public GWTCompilerTest() {
+ argProcessor = new GWTCompiler.ArgProcessor(options);
+ }
+
+ public void testAllValidArgs() {
+ assertProcessSuccess(argProcessor, "-logLevel", "DEBUG", "-style",
+ "PRETTY", "-ea", "-XdisableAggressiveOptimization", "-out", "myWww",
+ "-gen", "myGen", "c.g.g.h.H", "my.Module");
+
+ assertEquals(new File("myGen").getAbsoluteFile(),
+ options.getGenDir().getAbsoluteFile());
+ assertEquals(new File("myWww"), options.getOutDir());
+
+ assertEquals(TreeLogger.DEBUG, options.getLogLevel());
+ assertEquals(JsOutputOption.PRETTY, options.getOutput());
+ assertTrue(options.isEnableAssertions());
+ assertFalse(options.isAggressivelyOptimize());
+
+ assertEquals(2, options.getModuleNames().size());
+ assertEquals("c.g.g.h.H", options.getModuleNames().get(0));
+ assertEquals("my.Module", options.getModuleNames().get(1));
+ }
+
+ public void testDefaultArgs() {
+ assertProcessSuccess(argProcessor, "c.g.g.h.H");
+
+ assertEquals(null, options.getGenDir());
+ assertEquals(new File("").getAbsoluteFile(),
+ options.getOutDir().getAbsoluteFile());
+
+ assertEquals(TreeLogger.INFO, options.getLogLevel());
+ assertEquals(JsOutputOption.OBFUSCATED, options.getOutput());
+ assertFalse(options.isEnableAssertions());
+ assertTrue(options.isAggressivelyOptimize());
+
+ assertEquals(1, options.getModuleNames().size());
+ assertEquals("c.g.g.h.H", options.getModuleNames().get(0));
+ }
+
+ public void testForbiddenArgs() {
+ assertProcessFailure(argProcessor, "-localWorkers", "2");
+ assertProcessFailure(argProcessor, "-extra", "extra");
+ assertProcessFailure(argProcessor, "-war", "war");
+ assertProcessFailure(argProcessor, "-work", "work");
+ }
+}
diff --git a/dev/core/test/com/google/gwt/dev/GWTShellTest.java b/dev/core/test/com/google/gwt/dev/GWTShellTest.java
new file mode 100644
index 0000000..557189e
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/GWTShellTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009 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;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.dev.GWTShell.ShellOptionsImpl;
+import com.google.gwt.dev.HostedModeTest.MySCL;
+import com.google.gwt.dev.jjs.JsOutputOption;
+import com.google.gwt.dev.shell.BrowserWidgetHostChecker;
+
+import java.io.File;
+
+/**
+ * Test for deprecated {@link GWTShell}.
+ */
+@SuppressWarnings("deprecation")
+public class GWTShellTest extends ArgProcessorTestBase {
+
+ private final GWTShell.ArgProcessor argProcessor;
+ private final ShellOptionsImpl options = new ShellOptionsImpl();
+
+ public GWTShellTest() {
+ argProcessor = new GWTShell.ArgProcessor(options, false, false);
+ }
+
+ public void testAllValidArgs() {
+ assertProcessSuccess(argProcessor, "-port", "8080", "-whitelist", "white",
+ "-blacklist", "black", "-logLevel", "DEBUG", "-noserver", "-out",
+ "myWww", "-gen", "myGen", "http://www.google.com/", "foo");
+
+ assertNotNull(BrowserWidgetHostChecker.matchWhitelisted("white"));
+ assertNotNull(BrowserWidgetHostChecker.matchBlacklisted("black"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://127.0.0.1.40"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://127.0.0.1.40:88"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://127.0.0.1.40:88/"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://127.0.0.1.40:88/foo"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://localhost.evildomain.org"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://localhost.evildomain.org:88"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://localhost.evildomain.org:88/"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://localhost.evildomain.org:88/foo"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://localhost.evildomain.org/"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://localhost.evildomain.org/foo"));
+ assertFalse(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://www.evildomain.org/foo?http://localhost"));
+ assertTrue(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://127.0.0.1"));
+ assertTrue(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://127.0.0.1:88"));
+ assertTrue(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://127.0.0.1:88/"));
+ assertTrue(BrowserWidgetHostChecker.isAlwaysWhitelisted("http://127.0.0.1:88/foo"));
+
+ assertEquals(new File("myGen").getAbsoluteFile(),
+ options.getGenDir().getAbsoluteFile());
+ assertEquals(new File("myWww"), options.getOutDir());
+
+ assertEquals(TreeLogger.DEBUG, options.getLogLevel());
+
+ assertEquals(8080, options.getPort());
+ assertTrue(options.isNoServer());
+ assertEquals(2, options.getStartupURLs().size());
+ assertEquals("http://www.google.com/", options.getStartupURLs().get(0));
+ assertEquals("foo", options.getStartupURLs().get(1));
+ }
+
+ public void testDefaultArgs() {
+ assertProcessSuccess(argProcessor);
+
+ assertEquals(null, options.getGenDir());
+ assertEquals(new File("").getAbsoluteFile(),
+ options.getOutDir().getAbsoluteFile());
+
+ assertEquals(TreeLogger.INFO, options.getLogLevel());
+ assertEquals(JsOutputOption.OBFUSCATED, options.getOutput());
+ assertFalse(options.isEnableAssertions());
+ assertTrue(options.isAggressivelyOptimize());
+
+ assertEquals(8888, options.getPort());
+ assertFalse(options.isNoServer());
+ assertEquals(0, options.getStartupURLs().size());
+ }
+
+ public void testForbiddenArgs() {
+ assertProcessFailure(argProcessor, "-localWorkers", "2");
+ assertProcessFailure(argProcessor, "-extra", "extra");
+ assertProcessFailure(argProcessor, "-war", "war");
+ assertProcessFailure(argProcessor, "-work", "work");
+ assertProcessFailure(argProcessor, "-server", MySCL.class.getName());
+ }
+}
diff --git a/eclipse/dev/.classpath b/eclipse/dev/.classpath
index 4b1f5b4..fa17a0d 100644
--- a/eclipse/dev/.classpath
+++ b/eclipse/dev/.classpath
@@ -12,16 +12,35 @@
<classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/ant-launcher-1.6.5.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/catalina-1.0.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/catalina-optional-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/commons-beanutils-1.6.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/commons-collections-3.1.jar" sourcepath="/GWT_TOOLS/lib/tomcat/commons-collections-3.1-src.zip"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/commons-digester-1.5.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/commons-el-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/commons-logging-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/commons-modeler-1.1.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/jakarta-regexp-1.3.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/jasper-compiler-1.0.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/jasper-runtime-1.0.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/jsp-api-2.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/mx4j-jmx-1.1.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/naming-common-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/naming-factory-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/naming-java-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/naming-resources-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/servlet-api-2.5.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/servlet-api-2.4.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/servlets-common-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/servlets-default-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/servlets-invoker-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/tomcat-coyote-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/tomcat-http11-1.0.jar" sourcepath="/GWT_TOOLS/lib/tomcat/tomcat-http11-1.0.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/tomcat-jk2-2.1.jar"/>
+ <classpathentry kind="var" path="GWT_TOOLS/lib/tomcat/tomcat-util-5.1.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/htmlunit/htmlunit-2.9/htmlunit-core-js-2.9.jar" sourcepath="/GWT_TOOLS/lib/htmlunit/htmlunit-2.9/htmlunit-core-js-2.9-sources.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/htmlunit/htmlunit-2.9/htmlunit-2.9.jar" sourcepath="/GWT_TOOLS/lib/htmlunit/htmlunit-2.9/htmlunit-2.9-sources.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/protobuf/protobuf-2.2.0/protobuf-java-rebased-2.2.0.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/guava/guava-10.0.1/guava-10.0.1-rebased.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/jscomp/sourcemap-rebased.jar"/>
<classpathentry kind="var" path="GWT_TOOLS/lib/jscomp/r1649/compiler-rebased.jar"/>
- <classpathentry kind="var" path="GWT_TOOLS/lib/apache/commons/commons-collections-3.2.1.jar"/>
<classpathentry kind="output" path="bin"/>
</classpath>
