diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/AppVersionHandlerFactory.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/AppVersionHandlerFactory.java
index b47d25a3b..db978bf11 100644
--- a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/AppVersionHandlerFactory.java
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/AppVersionHandlerFactory.java
@@ -16,34 +16,34 @@
package com.google.apphosting.runtime.jetty9;
-import com.google.apphosting.base.AppVersionKey;
+import com.google.apphosting.api.ApiProxy;
+import com.google.apphosting.runtime.AppEngineConstants;
import com.google.apphosting.runtime.AppVersion;
-import com.google.apphosting.runtime.JettyConstants;
import com.google.apphosting.runtime.SessionsConfig;
import com.google.common.collect.ImmutableList;
import com.google.common.flogger.GoogleLogger;
import com.google.common.html.HtmlEscapers;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import javax.servlet.RequestDispatcher;
+import javax.servlet.ServletException;
+import javax.servlet.UnavailableException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.jsp.JspFactory;
import org.eclipse.jetty.annotations.AnnotationConfiguration;
import org.eclipse.jetty.server.Dispatcher;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.servlet.ErrorPageErrorHandler;
import org.eclipse.jetty.webapp.FragmentConfiguration;
import org.eclipse.jetty.webapp.MetaInfConfiguration;
import org.eclipse.jetty.webapp.WebAppContext;
import org.eclipse.jetty.webapp.WebXmlConfiguration;
-import javax.servlet.RequestDispatcher;
-import javax.servlet.ServletException;
-import javax.servlet.UnavailableException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.jsp.JspFactory;
-import java.io.File;
-import java.io.IOException;
-import java.io.PrintWriter;
-
/**
* {@code AppVersionHandlerFactory} implements a {@code Handler} for a given {@code AppVersionKey}.
*/
@@ -141,7 +141,6 @@ private final String[] getPreconfigurationClasses() {
}
private Handler doCreateHandler(AppVersion appVersion) throws ServletException {
- AppVersionKey appVersionKey = appVersion.getKey();
try {
File contextRoot = appVersion.getRootDirectory();
@@ -198,21 +197,43 @@ private Handler doCreateHandler(AppVersion appVersion) throws ServletException {
.setAsyncPersistence(sessionsConfig.isAsyncPersistence())
.setServletContextHandler(context);
- SessionManagerHandler unused = SessionManagerHandler.create(builder.build());
+ SessionManagerHandler ignored = SessionManagerHandler.create(builder.build());
// Pass the AppVersion on to any of our servlets (e.g. ResourceFileServlet).
- context.setAttribute(JettyConstants.APP_VERSION_CONTEXT_ATTR, appVersion);
-
- context.start();
- // Check to see if servlet filter initialization failed.
- Throwable unavailableCause = context.getUnavailableException();
- if (unavailableCause != null) {
- if (unavailableCause instanceof ServletException) {
- throw (ServletException) unavailableCause;
- } else {
- UnavailableException unavailableException =
- new UnavailableException("Initialization failed.");
- unavailableException.initCause(unavailableCause);
- throw unavailableException;
+ context.setAttribute(AppEngineConstants.APP_VERSION_CONTEXT_ATTR, appVersion);
+ if (Boolean.getBoolean(AppEngineConstants.HTTP_CONNECTOR_MODE)) {
+ context.addEventListener(
+ new ContextHandler.ContextScopeListener() {
+ @Override
+ public void enterScope(
+ ContextHandler.Context context, Request request, Object reason) {
+ if (request != null) {
+ ApiProxy.Environment environment =
+ (ApiProxy.Environment)
+ request.getAttribute(AppEngineConstants.ENVIRONMENT_ATTR);
+ if (environment != null) {
+ ApiProxy.setEnvironmentForCurrentThread(environment);
+ }
+ }
+ }
+
+ @Override
+ public void exitScope(ContextHandler.Context context, Request request) {
+ ApiProxy.clearEnvironmentForCurrentThread();
+ }
+ });
+ } else {
+ context.start();
+ // Check to see if servlet filter initialization failed.
+ Throwable unavailableCause = context.getUnavailableException();
+ if (unavailableCause != null) {
+ if (unavailableCause instanceof ServletException) {
+ throw (ServletException) unavailableCause;
+ } else {
+ UnavailableException unavailableException =
+ new UnavailableException("Initialization failed.");
+ unavailableException.initCause(unavailableCause);
+ throw unavailableException;
+ }
}
}
diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/AppVersionHandlerMap.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/AppVersionHandlerMap.java
index 9a2b7d191..adcbaa488 100644
--- a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/AppVersionHandlerMap.java
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/AppVersionHandlerMap.java
@@ -17,22 +17,20 @@
package com.google.apphosting.runtime.jetty9;
import com.google.apphosting.base.AppVersionKey;
+import com.google.apphosting.runtime.AppEngineConstants;
import com.google.apphosting.runtime.AppVersion;
-import com.google.apphosting.runtime.JettyConstants;
-import com.google.apphosting.runtime.SessionStore;
import com.google.apphosting.runtime.SessionStoreFactory;
-import org.eclipse.jetty.server.Handler;
-import org.eclipse.jetty.server.Request;
-import org.eclipse.jetty.server.Server;
-import org.eclipse.jetty.server.handler.AbstractHandlerContainer;
-
-import javax.servlet.ServletException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.handler.AbstractHandlerContainer;
/**
* {@code AppVersionHandlerMap} is a {@code HandlerContainer} that identifies each child {@code
@@ -41,7 +39,6 @@
* In order to identify which application version each request should be sent to, this class
* assumes that an attribute will be set on the {@code HttpServletRequest} with a value of the
* {@code AppVersionKey} that should be used.
- *
*/
public class AppVersionHandlerMap extends AbstractHandlerContainer {
private final AppVersionHandlerFactory appVersionHandlerFactory;
@@ -95,6 +92,10 @@ public synchronized Handler getHandler(AppVersionKey appVersionKey) throws Servl
return handler;
}
+ public AppVersion getAppVersion(AppVersionKey appVersionKey) {
+ return appVersionMap.get(appVersionKey);
+ }
+
/**
* Forward the specified request on to the {@link Handler} associated with its application
* version.
@@ -104,7 +105,7 @@ public void handle(
String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
AppVersionKey appVersionKey =
- (AppVersionKey) request.getAttribute(JettyConstants.APP_VERSION_KEY_REQUEST_ATTR);
+ (AppVersionKey) request.getAttribute(AppEngineConstants.APP_VERSION_KEY_REQUEST_ATTR);
if (appVersionKey == null) {
throw new ServletException("Request did not provide an application version");
}
@@ -127,24 +128,6 @@ public void handle(
}
}
- @Override
- protected void doStart() throws Exception {
- for (Handler handler : getHandlers()) {
- handler.start();
- }
-
- super.doStart();
- }
-
- @Override
- protected void doStop() throws Exception {
- super.doStop();
-
- for (Handler handler : getHandlers()) {
- handler.stop();
- }
- }
-
@Override
public void setServer(Server server) {
super.setServer(server);
@@ -159,29 +142,17 @@ public Handler[] getHandlers() {
return handlerMap.values().toArray(new Handler[0]);
}
- /**
- * Not supported.
- *
- * @throws UnsupportedOperationException
- */
+ /** Not supported. */
public void setHandlers(Handler[] handlers) {
throw new UnsupportedOperationException();
}
- /**
- * Not supported.
- *
- * @throws UnsupportedOperationException
- */
+ /** Not supported. */
public void addHandler(Handler handler) {
throw new UnsupportedOperationException();
}
- /**
- * Not supported.
- *
- * @throws UnsupportedOperationException
- */
+ /** Not supported. */
public void removeHandler(Handler handler) {
throw new UnsupportedOperationException();
}
diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyHttpHandler.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyHttpHandler.java
new file mode 100644
index 000000000..3146c22cd
--- /dev/null
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyHttpHandler.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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
+ *
+ * https://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.apphosting.runtime.jetty9;
+
+import static com.google.apphosting.runtime.RequestRunner.WAIT_FOR_USER_RUNNABLE_DEADLINE;
+import static com.google.common.base.Verify.verify;
+
+import com.google.appengine.api.ThreadManager;
+import com.google.apphosting.api.ApiProxy;
+import com.google.apphosting.base.AppVersionKey;
+import com.google.apphosting.base.protos.EmptyMessage;
+import com.google.apphosting.base.protos.RuntimePb;
+import com.google.apphosting.runtime.ApiProxyImpl;
+import com.google.apphosting.runtime.AppEngineConstants;
+import com.google.apphosting.runtime.AppVersion;
+import com.google.apphosting.runtime.BackgroundRequestCoordinator;
+import com.google.apphosting.runtime.LocalRpcContext;
+import com.google.apphosting.runtime.RequestManager;
+import com.google.apphosting.runtime.RequestRunner.EagerRunner;
+import com.google.apphosting.runtime.ResponseAPIData;
+import com.google.apphosting.runtime.ServletEngineAdapter;
+import com.google.common.flogger.GoogleLogger;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.time.Duration;
+import java.util.concurrent.TimeoutException;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.handler.HandlerWrapper;
+
+/**
+ * This class replicates the behaviour of the {@link RequestRunner} for Requests which do not come
+ * through RPC. It should be added as a {@link Handler} to the Jetty {@link Server} wrapping the
+ * {@code AppEngineWebAppContext}.
+ *
+ *
This uses the {@link RequestManager} to start any AppEngine state associated with this request
+ * including the {@link ApiProxy.Environment} which it sets as a request attribute at {@link
+ * AppEngineConstants#ENVIRONMENT_ATTR}. This request attribute is pulled out by {@code
+ * ContextScopeListener}s installed by the {@code AppVersionHandlerFactory} implementations so that
+ * the {@link ApiProxy.Environment} is available all threads which are used to handle the request.
+ */
+public class JettyHttpHandler extends HandlerWrapper {
+ private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
+
+ private final boolean passThroughPrivateHeaders;
+ private final AppInfoFactory appInfoFactory;
+ private final AppVersionKey appVersionKey;
+ private final AppVersion appVersion;
+ private final RequestManager requestManager;
+ private final BackgroundRequestCoordinator coordinator;
+
+ public JettyHttpHandler(
+ ServletEngineAdapter.Config runtimeOptions,
+ AppVersion appVersion,
+ AppVersionKey appVersionKey,
+ AppInfoFactory appInfoFactory) {
+ this.passThroughPrivateHeaders = runtimeOptions.passThroughPrivateHeaders();
+ this.appInfoFactory = appInfoFactory;
+ this.appVersionKey = appVersionKey;
+ this.appVersion = appVersion;
+
+ ApiProxyImpl apiProxyImpl = (ApiProxyImpl) ApiProxy.getDelegate();
+ coordinator = apiProxyImpl.getBackgroundRequestCoordinator();
+ requestManager = (RequestManager) apiProxyImpl.getRequestThreadManager();
+ }
+
+ @Override
+ public void handle(
+ String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+
+ // This handler cannot be used with anything else which establishes an environment
+ // (e.g. RpcConnection).
+ verify(request.getAttribute(AppEngineConstants.ENVIRONMENT_ATTR) == null);
+ JettyRequestAPIData genericRequest =
+ new JettyRequestAPIData(baseRequest, request, appInfoFactory, passThroughPrivateHeaders);
+ JettyResponseAPIData genericResponse =
+ new JettyResponseAPIData(baseRequest.getResponse(), response);
+
+ // Read time remaining in request from headers and pass value to LocalRpcContext for use in
+ // reporting remaining time until deadline for API calls (see b/154745969)
+ Duration timeRemaining = genericRequest.getTimeRemaining();
+
+ ThreadGroup currentThreadGroup = Thread.currentThread().getThreadGroup();
+ LocalRpcContext context =
+ new LocalRpcContext<>(EmptyMessage.class, timeRemaining);
+ RequestManager.RequestToken requestToken =
+ requestManager.startRequest(
+ appVersion, context, genericRequest, genericResponse, currentThreadGroup);
+
+ // Set the environment as a request attribute, so it can be pulled out and set for async
+ // threads.
+ ApiProxy.Environment currentEnvironment = ApiProxy.getCurrentEnvironment();
+ request.setAttribute(AppEngineConstants.ENVIRONMENT_ATTR, currentEnvironment);
+
+ try {
+ dispatchRequest(target, requestToken, genericRequest, genericResponse);
+ if (!baseRequest.isHandled()) {
+ response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "request not handled");
+ }
+ } catch (
+ @SuppressWarnings("InterruptedExceptionSwallowed")
+ Throwable ex) {
+ // Note we do intentionally swallow InterruptException.
+ // We will report the exception via the rpc. We don't mark this thread as interrupted because
+ // ThreadGroupPool would use that as a signal to remove the thread from the pool; we don't
+ // need that.
+ handleException(ex, requestToken, genericResponse);
+ response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex.getMessage());
+ } finally {
+ requestManager.finishRequest(requestToken);
+ }
+ // Do not put this in a final block. If we propagate an
+ // exception the callback will be invoked automatically.
+ genericResponse.finishWithResponse(context);
+ // We don't want threads used for background requests to go back
+ // in the thread pool, because users may have stashed references
+ // to them or may be expecting them to exit. Setting the
+ // interrupt bit causes the pool to drop them.
+ if (genericRequest.getRequestType() == RuntimePb.UPRequest.RequestType.BACKGROUND) {
+ Thread.currentThread().interrupt();
+ }
+ }
+
+ private void dispatchRequest(
+ String target,
+ RequestManager.RequestToken requestToken,
+ JettyRequestAPIData request,
+ JettyResponseAPIData response)
+ throws Throwable {
+ switch (request.getRequestType()) {
+ case SHUTDOWN:
+ logger.atInfo().log("Shutting down requests");
+ requestManager.shutdownRequests(requestToken);
+ request.getBaseRequest().setHandled(true);
+ break;
+ case BACKGROUND:
+ dispatchBackgroundRequest(request);
+ request.getBaseRequest().setHandled(true);
+ break;
+ case OTHER:
+ dispatchServletRequest(target, request, response);
+ break;
+ }
+ }
+
+ private void dispatchServletRequest(
+ String target, JettyRequestAPIData request, JettyResponseAPIData response) throws Throwable {
+ Request baseRequest = request.getBaseRequest();
+ HttpServletRequest httpServletRequest = request.getHttpServletRequest();
+ HttpServletResponse httpServletResponse = response.getHttpServletResponse();
+ baseRequest.setAttribute(AppEngineConstants.APP_VERSION_KEY_REQUEST_ATTR, appVersionKey);
+
+ // Environment is set in a request attribute which is set/unset for async threads by
+ // a ContextScopeListener created inside the AppVersionHandlerFactory.
+ super.handle(target, baseRequest, httpServletRequest, httpServletResponse);
+ }
+
+ private void dispatchBackgroundRequest(JettyRequestAPIData request)
+ throws InterruptedException, TimeoutException {
+ String requestId = getBackgroundRequestId(request);
+ // The interface of coordinator.waitForUserRunnable() requires us to provide the app code with a
+ // working thread *in the same exchange* where we get the runnable the user wants to run in the
+ // thread. This prevents us from actually directly feeding that runnable to the thread. To work
+ // around this conundrum, we create an EagerRunner, which lets us start running the thread
+ // without knowing yet what we want to run.
+
+ // Create an ordinary request thread as a child of this background thread.
+ EagerRunner eagerRunner = new EagerRunner();
+ Thread thread = ThreadManager.createThreadForCurrentRequest(eagerRunner);
+
+ // Give this thread to the app code and get its desired runnable in response:
+ Runnable runnable =
+ coordinator.waitForUserRunnable(
+ requestId, thread, WAIT_FOR_USER_RUNNABLE_DEADLINE.toMillis());
+
+ // Finally, hand that runnable to the thread so it can actually start working.
+ // This will block until Thread.start() is called by the app code. This is by design: we must
+ // not exit this request handler until the thread has started *and* completed, otherwise the
+ // serving infrastructure will cancel our ability to make API calls. We're effectively "holding
+ // open the door" on the spawned thread's ability to make App Engine API calls.
+ // Now set the context class loader to the UserClassLoader for the application
+ // and pass control to the Runnable the user provided.
+ ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
+ Thread.currentThread().setContextClassLoader(appVersion.getClassLoader());
+ try {
+ eagerRunner.supplyRunnable(runnable);
+ } finally {
+ Thread.currentThread().setContextClassLoader(oldClassLoader);
+ }
+ // Wait for the thread to end:
+ thread.join();
+ }
+
+ private void handleException(
+ Throwable ex, RequestManager.RequestToken requestToken, ResponseAPIData response) {
+ // Unwrap ServletException, either from javax or from jakarta exception:
+ try {
+ java.lang.reflect.Method getRootCause = ex.getClass().getMethod("getRootCause");
+ Object rootCause = getRootCause.invoke(ex);
+ if (rootCause != null) {
+ ex = (Throwable) rootCause;
+ }
+ } catch (Throwable ignore) {
+ // We do want to ignore there, failure is propagated below in the protocol buffer.
+ }
+ String msg = "Uncaught exception from servlet";
+ logger.atWarning().withCause(ex).log("%s", msg);
+ // Don't use ApiProxy here, because we don't know what state the
+ // environment/delegate are in.
+ requestToken.addAppLogMessage(ApiProxy.LogRecord.Level.fatal, formatLogLine(msg, ex));
+
+ if (shouldKillCloneAfterException(ex)) {
+ logger.atSevere().log("Detected a dangerous exception, shutting down clone nicely.");
+ response.setTerminateClone(true);
+ }
+ RuntimePb.UPResponse.ERROR error = RuntimePb.UPResponse.ERROR.APP_FAILURE;
+ setFailure(response, error, "Unexpected exception from servlet: " + ex);
+ }
+
+ /** Create a failure response from the given code and message. */
+ public static void setFailure(
+ ResponseAPIData response, RuntimePb.UPResponse.ERROR error, String message) {
+ logger.atWarning().log("Runtime failed: %s, %s", error, message);
+ // If the response is already set, use that -- it's probably more
+ // specific (e.g. THREADS_STILL_RUNNING).
+ if (response.getError() == RuntimePb.UPResponse.ERROR.OK_VALUE) {
+ response.error(error.getNumber(), message);
+ }
+ }
+
+ private String formatLogLine(String message, Throwable ex) {
+ StringWriter stringWriter = new StringWriter();
+ PrintWriter printWriter = new PrintWriter(stringWriter);
+ printWriter.println(message);
+ ex.printStackTrace(printWriter);
+ return stringWriter.toString();
+ }
+
+ public static boolean shouldKillCloneAfterException(Throwable th) {
+ while (th != null) {
+ if (th instanceof OutOfMemoryError) {
+ return true;
+ }
+ try {
+ Throwable[] suppressed = th.getSuppressed();
+ if (suppressed != null) {
+ for (Throwable s : suppressed) {
+ if (shouldKillCloneAfterException(s)) {
+ return true;
+ }
+ }
+ }
+ } catch (OutOfMemoryError ex) {
+ return true;
+ }
+ // TODO: Consider checking for other subclasses of
+ // VirtualMachineError, but probably not StackOverflowError.
+ th = th.getCause();
+ }
+ return false;
+ }
+
+ private String getBackgroundRequestId(JettyRequestAPIData upRequest) {
+ String backgroundRequestId = upRequest.getBackgroundRequestId();
+ if (backgroundRequestId == null) {
+ throw new IllegalArgumentException("Did not receive a background request identifier.");
+ }
+ return backgroundRequestId;
+ }
+}
diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyHttpProxy.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyHttpProxy.java
index b25b5048d..ec75a1683 100644
--- a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyHttpProxy.java
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyHttpProxy.java
@@ -17,30 +17,23 @@
package com.google.apphosting.runtime.jetty9;
import com.google.apphosting.base.protos.AppLogsPb;
-import com.google.apphosting.base.protos.AppinfoPb;
-import com.google.apphosting.base.protos.EmptyMessage;
import com.google.apphosting.base.protos.RuntimePb;
import com.google.apphosting.base.protos.RuntimePb.UPRequest;
import com.google.apphosting.base.protos.RuntimePb.UPResponse;
+import com.google.apphosting.runtime.LocalRpcContext;
import com.google.apphosting.runtime.ServletEngineAdapter;
-import com.google.apphosting.runtime.anyrpc.AnyRpcServerContext;
import com.google.apphosting.runtime.anyrpc.EvaluationRuntimeServerInterface;
import com.google.common.base.Ascii;
import com.google.common.base.Throwables;
import com.google.common.flogger.GoogleLogger;
import com.google.common.primitives.Ints;
-import com.google.common.util.concurrent.SettableFuture;
-import com.google.protobuf.MessageLite;
-import java.io.IOException;
import java.time.Duration;
import java.util.Map;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.jetty.http.HttpCompliance;
-import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.HttpConfiguration;
import org.eclipse.jetty.server.HttpConnectionFactory;
import org.eclipse.jetty.server.Request;
@@ -83,7 +76,6 @@ public static void startServer(ServletEngineAdapter.Config runtimeOptions) {
System.setProperty(JETTY_LOG_CLASS, JETTY_STDERRLOG);
ForwardingHandler handler = new ForwardingHandler(runtimeOptions, System.getenv());
- handler.init();
Server server = newServer(runtimeOptions, handler);
server.start();
} catch (Exception ex) {
@@ -91,17 +83,14 @@ public static void startServer(ServletEngineAdapter.Config runtimeOptions) {
}
}
- public static Server newServer(
- ServletEngineAdapter.Config runtimeOptions, ForwardingHandler handler) {
- Server server = new Server();
-
- ServerConnector c =
+ public static ServerConnector newConnector(
+ Server server, ServletEngineAdapter.Config runtimeOptions) {
+ ServerConnector connector =
new JettyServerConnectorWithReusePort(server, runtimeOptions.jettyReusePort());
- c.setHost(runtimeOptions.jettyHttpAddress().getHost());
- c.setPort(runtimeOptions.jettyHttpAddress().getPort());
- server.setConnectors(new Connector[] {c});
+ connector.setHost(runtimeOptions.jettyHttpAddress().getHost());
+ connector.setPort(runtimeOptions.jettyHttpAddress().getPort());
- HttpConnectionFactory factory = c.getConnectionFactory(HttpConnectionFactory.class);
+ HttpConnectionFactory factory = connector.getConnectionFactory(HttpConnectionFactory.class);
factory.setHttpCompliance(
RpcConnector.LEGACY_MODE ? HttpCompliance.RFC7230_LEGACY : HttpCompliance.RFC7230);
@@ -112,72 +101,32 @@ public static Server newServer(
config.setSendServerVersion(false);
config.setSendXPoweredBy(false);
+ return connector;
+ }
+
+ public static void insertHandlers(Server server) {
SizeLimitHandler sizeLimitHandler = new SizeLimitHandler(MAX_REQUEST_SIZE, -1);
- sizeLimitHandler.setHandler(handler);
+ sizeLimitHandler.setHandler(server.getHandler());
GzipHandler gzip = new GzipHandler();
gzip.setInflateBufferSize(8 * 1024);
gzip.setHandler(sizeLimitHandler);
gzip.setExcludedAgentPatterns();
-
- // Include all methods for the GzipHandler.
- gzip.setIncludedMethods();
-
+ gzip.setIncludedMethods(); // Include all methods for the GzipHandler.
server.setHandler(gzip);
-
- logger.atInfo().log("Starting Jetty http server for Java runtime proxy.");
- return server;
}
- private static class LocalRpcContext implements AnyRpcServerContext {
- // We just dole out sequential ids here so we can tell requests apart in the logs.
- private static final AtomicLong globalIds = new AtomicLong();
-
- private final Class responseMessageClass;
- private final long startTimeMillis;
- private final Duration timeRemaining;
- private final SettableFuture futureResponse = SettableFuture.create();
- private final long globalId = globalIds.getAndIncrement();
-
- private LocalRpcContext(Class responseMessageClass) {
- this(responseMessageClass, Duration.ofNanos((long) Double.MAX_VALUE));
- }
-
- private LocalRpcContext(Class responseMessageClass, Duration timeRemaining) {
- this.responseMessageClass = responseMessageClass;
- this.startTimeMillis = System.currentTimeMillis();
- this.timeRemaining = timeRemaining;
- }
-
- @Override
- public void finishWithResponse(MessageLite response) {
- futureResponse.set(responseMessageClass.cast(response));
- }
-
- M getResponse() throws ExecutionException, InterruptedException {
- return futureResponse.get();
- }
-
- @Override
- public void finishWithAppError(int appErrorCode, String errorDetail) {
- String message = "AppError: code " + appErrorCode + "; errorDetail " + errorDetail;
- futureResponse.setException(new RuntimeException(message));
- }
-
- @Override
- public Duration getTimeRemaining() {
- return timeRemaining;
- }
+ public static Server newServer(
+ ServletEngineAdapter.Config runtimeOptions, ForwardingHandler handler) {
+ Server server = new Server();
+ server.setHandler(handler);
+ insertHandlers(server);
- @Override
- public long getGlobalId() {
- return globalId;
- }
+ ServerConnector connector = newConnector(server, runtimeOptions);
+ server.addConnector(connector);
- @Override
- public long getStartTimeMillis() {
- return startTimeMillis;
- }
+ logger.atInfo().log("Starting Jetty http server for Java runtime proxy.");
+ return server;
}
/**
@@ -189,37 +138,17 @@ public static class ForwardingHandler extends AbstractHandler {
private static final String X_APPENGINE_TIMEOUT_MS = "x-appengine-timeout-ms";
- private final String applicationRoot;
- private final String fixedApplicationPath;
- private final AppInfoFactory appInfoFactory;
private final EvaluationRuntimeServerInterface evaluationRuntimeServerInterface;
private final UPRequestTranslator upRequestTranslator;
- public ForwardingHandler(ServletEngineAdapter.Config runtimeOptions, Map env)
- throws ExecutionException, InterruptedException, IOException {
- this.applicationRoot = runtimeOptions.applicationRoot();
- this.fixedApplicationPath = runtimeOptions.fixedApplicationPath();
- this.appInfoFactory = new AppInfoFactory(env);
+ public ForwardingHandler(ServletEngineAdapter.Config runtimeOptions, Map env) {
+ AppInfoFactory appInfoFactory = new AppInfoFactory(env);
this.evaluationRuntimeServerInterface = runtimeOptions.evaluationRuntimeServerInterface();
this.upRequestTranslator =
new UPRequestTranslator(
- this.appInfoFactory,
+ appInfoFactory,
runtimeOptions.passThroughPrivateHeaders(),
- /*skipPostData=*/ false);
- }
-
- private void init() {
- /* The init actions are not done in the constructor as they are not used when testing */
- try {
- AppinfoPb.AppInfo appinfo =
- appInfoFactory.getAppInfoFromFile(applicationRoot, fixedApplicationPath);
- // TODO Should we also call ApplyCloneSettings()?
- LocalRpcContext context = new LocalRpcContext<>(EmptyMessage.class);
- evaluationRuntimeServerInterface.addAppVersion(context, appinfo);
- Object unused = context.getResponse();
- } catch (Exception e) {
- throw new IllegalStateException(e);
- }
+ /* skipPostData= */ false);
}
/**
@@ -289,6 +218,5 @@ private static Level toJavaLevel(long level) {
}
}
- private JettyHttpProxy() {
- }
+ private JettyHttpProxy() {}
}
diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyRequestAPIData.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyRequestAPIData.java
new file mode 100644
index 000000000..43fd0e75d
--- /dev/null
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyRequestAPIData.java
@@ -0,0 +1,503 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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
+ *
+ * https://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.apphosting.runtime.jetty9;
+
+import static com.google.apphosting.base.protos.RuntimePb.UPRequest.RequestType.OTHER;
+import static com.google.apphosting.runtime.AppEngineConstants.BACKGROUND_REQUEST_URL;
+import static com.google.apphosting.runtime.AppEngineConstants.DEFAULT_SECRET_KEY;
+import static com.google.apphosting.runtime.AppEngineConstants.IS_ADMIN_HEADER_VALUE;
+import static com.google.apphosting.runtime.AppEngineConstants.IS_TRUSTED;
+import static com.google.apphosting.runtime.AppEngineConstants.PRIVATE_APPENGINE_HEADERS;
+import static com.google.apphosting.runtime.AppEngineConstants.SKIP_ADMIN_CHECK_ATTR;
+import static com.google.apphosting.runtime.AppEngineConstants.WARMUP_IP;
+import static com.google.apphosting.runtime.AppEngineConstants.WARMUP_REQUEST_URL;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_API_TICKET;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_APPSERVER_DATACENTER;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_APPSERVER_TASK_BNS;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_AUTH_DOMAIN;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_BACKGROUNDREQUEST;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_DEFAULT_VERSION_HOSTNAME;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_GAIA_AUTHUSER;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_GAIA_ID;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_GAIA_SESSION;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_HTTPS;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_ID_HASH;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_LOAS_PEER_USERNAME;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_QUEUENAME;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_REQUEST_LOG_ID;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_TIMEOUT_MS;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_TRUSTED_IP_REQUEST;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_EMAIL;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_ID;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_IP;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_IS_ADMIN;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_ORGANIZATION;
+import static com.google.apphosting.runtime.AppEngineConstants.X_CLOUD_TRACE_CONTEXT;
+import static com.google.apphosting.runtime.AppEngineConstants.X_FORWARDED_PROTO;
+import static com.google.apphosting.runtime.AppEngineConstants.X_GOOGLE_INTERNAL_PROFILER;
+import static com.google.apphosting.runtime.AppEngineConstants.X_GOOGLE_INTERNAL_SKIPADMINCHECK;
+
+import com.google.apphosting.base.protos.HttpPb;
+import com.google.apphosting.base.protos.RuntimePb;
+import com.google.apphosting.base.protos.TracePb;
+import com.google.apphosting.base.protos.TracePb.TraceContextProto;
+import com.google.apphosting.runtime.RequestAPIData;
+import com.google.apphosting.runtime.TraceContextHelper;
+import com.google.common.base.Strings;
+import com.google.common.flogger.GoogleLogger;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.stream.Stream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletRequestWrapper;
+import org.eclipse.jetty.http.HttpFields;
+import org.eclipse.jetty.http.HttpScheme;
+import org.eclipse.jetty.http.HttpURI;
+import org.eclipse.jetty.server.Request;
+
+/**
+ * Implementation for the {@link RequestAPIData} to allow for the Jetty {@link Request} to be used
+ * directly with the Java Runtime without any conversion into the RPC {@link RuntimePb.UPRequest}.
+ *
+ * This will interpret the AppEngine specific headers defined in {@link AppEngineConstants}. The
+ * request returned by {@link #getBaseRequest()} is to be passed to the application and will hide
+ * any private appengine headers from {@link AppEngineConstants#PRIVATE_APPENGINE_HEADERS}.
+ */
+public class JettyRequestAPIData implements RequestAPIData {
+ private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
+
+ private final Request baseRequest;
+ private final HttpServletRequest httpServletRequest;
+ private final AppInfoFactory appInfoFactory;
+ private final String url;
+ private Duration duration = Duration.ofNanos(Long.MAX_VALUE);
+ private RuntimePb.UPRequest.RequestType requestType = OTHER;
+ private String authDomain = "";
+ private boolean isTrusted;
+ private boolean isTrustedApp;
+ private boolean isAdmin;
+ private boolean isHttps;
+ private boolean isOffline;
+ private TracePb.TraceContextProto traceContext;
+ private String obfuscatedGaiaId;
+ private String userOrganization = "";
+ private String peerUsername;
+ private long gaiaId;
+ private String authUser;
+ private String gaiaSession;
+ private String appserverDataCenter;
+ String appserverTaskBns;
+ String eventIdHash;
+ private String requestLogId;
+ private String defaultVersionHostname;
+ private String email = "";
+ private String securityTicket;
+ private String backgroundRequestId;
+
+ public JettyRequestAPIData(
+ Request request,
+ HttpServletRequest httpServletRequest,
+ AppInfoFactory appInfoFactory,
+ boolean passThroughPrivateHeaders) {
+ this.appInfoFactory = appInfoFactory;
+
+ // Can be overridden by X_APPENGINE_USER_IP header.
+ String userIp = request.getRemoteAddr();
+
+ // Can be overridden by X_APPENGINE_API_TICKET header.
+ this.securityTicket = DEFAULT_SECRET_KEY;
+
+ HttpFields fields = new HttpFields();
+ List headerNames = Collections.list(request.getHeaderNames());
+ for (String headerName : headerNames) {
+ String name = headerName.toLowerCase(Locale.ROOT);
+ String value = request.getHeader(headerName);
+ if (Strings.isNullOrEmpty(value)) {
+ continue;
+ }
+
+ switch (name) {
+ case X_APPENGINE_TRUSTED_IP_REQUEST:
+ // If there is a value, then the application is trusted
+ // If the value is IS_TRUSTED, then the user is trusted
+ isTrusted = value.equals(IS_TRUSTED);
+ isTrustedApp = true;
+ break;
+ case X_APPENGINE_HTTPS:
+ isHttps = value.equals("on");
+ break;
+ case X_APPENGINE_USER_IP:
+ userIp = value;
+ break;
+ case X_FORWARDED_PROTO:
+ isHttps = value.equals("https");
+ break;
+ case X_APPENGINE_USER_ID:
+ obfuscatedGaiaId = value;
+ break;
+ case X_APPENGINE_USER_ORGANIZATION:
+ userOrganization = value;
+ break;
+ case X_APPENGINE_LOAS_PEER_USERNAME:
+ peerUsername = value;
+ break;
+ case X_APPENGINE_GAIA_ID:
+ gaiaId = Long.parseLong(value);
+ break;
+ case X_APPENGINE_GAIA_AUTHUSER:
+ authUser = value;
+ break;
+ case X_APPENGINE_GAIA_SESSION:
+ gaiaSession = value;
+ break;
+ case X_APPENGINE_APPSERVER_DATACENTER:
+ appserverDataCenter = value;
+ break;
+ case X_APPENGINE_APPSERVER_TASK_BNS:
+ appserverTaskBns = value;
+ break;
+ case X_APPENGINE_ID_HASH:
+ eventIdHash = value;
+ break;
+ case X_APPENGINE_REQUEST_LOG_ID:
+ requestLogId = value;
+ break;
+ case X_APPENGINE_DEFAULT_VERSION_HOSTNAME:
+ defaultVersionHostname = value;
+ break;
+ case X_APPENGINE_USER_IS_ADMIN:
+ isAdmin = Objects.equals(value, IS_ADMIN_HEADER_VALUE);
+ break;
+ case X_APPENGINE_USER_EMAIL:
+ email = value;
+ break;
+ case X_APPENGINE_AUTH_DOMAIN:
+ authDomain = value;
+ break;
+ case X_APPENGINE_API_TICKET:
+ securityTicket = value;
+ break;
+
+ case X_CLOUD_TRACE_CONTEXT:
+ try {
+ traceContext = TraceContextHelper.parseTraceContextHeader(value);
+ } catch (NumberFormatException e) {
+ logger.atWarning().withCause(e).log("Could not parse trace context header: %s", value);
+ }
+ break;
+
+ case X_GOOGLE_INTERNAL_SKIPADMINCHECK:
+ request.setAttribute(SKIP_ADMIN_CHECK_ATTR, true);
+ isHttps = true;
+ break;
+
+ case X_APPENGINE_QUEUENAME:
+ request.setAttribute(SKIP_ADMIN_CHECK_ATTR, true);
+ isOffline = true;
+ break;
+
+ case X_APPENGINE_TIMEOUT_MS:
+ duration = Duration.ofMillis(Long.parseLong(value));
+ break;
+
+ case X_GOOGLE_INTERNAL_PROFILER:
+ /* TODO: what to do here?
+ try {
+ TextFormat.merge(value, upReqBuilder.getProfilerSettingsBuilder());
+ } catch (IOException ex) {
+ throw new IllegalStateException("X-Google-Internal-Profiler read content error:", ex);
+ }
+ */
+ break;
+
+ case X_APPENGINE_BACKGROUNDREQUEST:
+ backgroundRequestId = value;
+ break;
+
+ default:
+ break;
+ }
+
+ if (passThroughPrivateHeaders || !PRIVATE_APPENGINE_HEADERS.contains(name)) {
+ // Only non AppEngine specific headers are passed to the application.
+ fields.add(name, value);
+ }
+ }
+
+ HttpURI httpUri;
+ boolean isSecure;
+ if (isHttps) {
+ httpUri = new HttpURI(request.getHttpURI());
+ httpUri.setScheme(HttpScheme.HTTPS.asString());
+ isSecure = true;
+ } else {
+ httpUri = request.getHttpURI();
+ isSecure = request.isSecure();
+ }
+
+ String decodedPath = request.getHttpURI().getDecodedPath();
+ if (Objects.equals(decodedPath, BACKGROUND_REQUEST_URL)) {
+ if (Objects.equals(userIp, WARMUP_IP)) {
+ requestType = RuntimePb.UPRequest.RequestType.BACKGROUND;
+ }
+ } else if (Objects.equals(decodedPath, WARMUP_REQUEST_URL)) {
+ if (Objects.equals(userIp, WARMUP_IP)) {
+ // This request came from within App Engine via secure internal channels; tell Jetty
+ // it's HTTPS to avoid 403 because of web.xml security-constraint checks.
+ isHttps = true;
+ }
+ }
+
+ HttpURI uri = new HttpURI(httpUri);
+ uri.setQuery(null);
+ StringBuilder sb = new StringBuilder(uri.toString());
+ String query = httpUri.getQuery();
+ // No need to escape, URL retains any %-escaping it might have, which is what we want.
+ if (query != null) {
+ sb.append('?').append(query);
+ }
+ url = sb.toString();
+
+ if (traceContext == null) {
+ traceContext = TraceContextProto.getDefaultInstance();
+ }
+
+ this.httpServletRequest =
+ new HttpServletRequestWrapper(httpServletRequest) {
+
+ @Override
+ public long getDateHeader(String name) {
+ return fields.getDateField(name);
+ }
+
+ @Override
+ public String getHeader(String name) {
+ return fields.get(name);
+ }
+
+ @Override
+ public Enumeration getHeaders(String name) {
+ return fields.getValues(name);
+ }
+
+ @Override
+ public Enumeration getHeaderNames() {
+ return fields.getFieldNames();
+ }
+
+ @Override
+ public int getIntHeader(String name) {
+ return Math.toIntExact(fields.getLongField(name));
+ }
+
+ @Override
+ public String getRequestURI() {
+ return httpUri.getPath();
+ }
+
+ @Override
+ public String getScheme() {
+ return httpUri.getScheme();
+ }
+
+ @Override
+ public boolean isSecure() {
+ return isSecure;
+ }
+ };
+
+ this.baseRequest = request;
+ }
+
+ public Request getBaseRequest() {
+ return baseRequest;
+ }
+
+ public HttpServletRequest getHttpServletRequest() {
+ return httpServletRequest;
+ }
+
+ @Override
+ public Stream getHeadersList() {
+ return baseRequest.getHttpFields().stream()
+ .map(
+ f ->
+ HttpPb.ParsedHttpHeader.newBuilder()
+ .setKey(f.getName())
+ .setValue(f.getValue())
+ .build());
+ }
+
+ @Override
+ public String getUrl() {
+ return url;
+ }
+
+ @Override
+ public RuntimePb.UPRequest.RequestType getRequestType() {
+ return requestType;
+ }
+
+ @Override
+ public String getBackgroundRequestId() {
+ return backgroundRequestId;
+ }
+
+ @Override
+ public boolean hasTraceContext() {
+ return traceContext != null;
+ }
+
+ @Override
+ public TracePb.TraceContextProto getTraceContext() {
+ return traceContext;
+ }
+
+ @Override
+ public String getSecurityLevel() {
+ // TODO(b/78515194) Need to find a mapping for this field.
+ return null;
+ }
+
+ @Override
+ public boolean getIsOffline() {
+ return isOffline;
+ }
+
+ @Override
+ public String getAppId() {
+ return appInfoFactory.getGaeApplication();
+ }
+
+ @Override
+ public String getModuleId() {
+ return appInfoFactory.getGaeService();
+ }
+
+ @Override
+ public String getModuleVersionId() {
+ return appInfoFactory.getGaeServiceVersion();
+ }
+
+ @Override
+ public String getObfuscatedGaiaId() {
+ return obfuscatedGaiaId;
+ }
+
+ @Override
+ public String getUserOrganization() {
+ return userOrganization;
+ }
+
+ @Override
+ public boolean getIsTrustedApp() {
+ return isTrustedApp;
+ }
+
+ @Override
+ public boolean getTrusted() {
+ return isTrusted;
+ }
+
+ @Override
+ public String getPeerUsername() {
+ return peerUsername;
+ }
+
+ @Override
+ public long getGaiaId() {
+ return gaiaId;
+ }
+
+ @Override
+ public String getAuthuser() {
+ return authUser;
+ }
+
+ @Override
+ public String getGaiaSession() {
+ return gaiaSession;
+ }
+
+ @Override
+ public String getAppserverDatacenter() {
+ return appserverDataCenter;
+ }
+
+ @Override
+ public String getAppserverTaskBns() {
+ return appserverTaskBns;
+ }
+
+ @Override
+ public boolean hasEventIdHash() {
+ return eventIdHash != null;
+ }
+
+ @Override
+ public String getEventIdHash() {
+ return eventIdHash;
+ }
+
+ @Override
+ public boolean hasRequestLogId() {
+ return requestLogId != null;
+ }
+
+ @Override
+ public String getRequestLogId() {
+ return requestLogId;
+ }
+
+ @Override
+ public boolean hasDefaultVersionHostname() {
+ return defaultVersionHostname != null;
+ }
+
+ @Override
+ public String getDefaultVersionHostname() {
+ return defaultVersionHostname;
+ }
+
+ @Override
+ public boolean getIsAdmin() {
+ return isAdmin;
+ }
+
+ @Override
+ public String getEmail() {
+ return email;
+ }
+
+ @Override
+ public String getAuthDomain() {
+ return authDomain;
+ }
+
+ @Override
+ public String getSecurityTicket() {
+ return securityTicket;
+ }
+
+ public Duration getTimeRemaining() {
+ return duration;
+ }
+}
diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyResponseAPIData.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyResponseAPIData.java
new file mode 100644
index 000000000..7a1ed5d53
--- /dev/null
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyResponseAPIData.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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
+ *
+ * https://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.apphosting.runtime.jetty9;
+
+import com.google.apphosting.base.protos.AppLogsPb;
+import com.google.apphosting.base.protos.RuntimePb;
+import com.google.apphosting.runtime.ResponseAPIData;
+import com.google.apphosting.runtime.anyrpc.AnyRpcServerContext;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.ByteString;
+import java.util.Collection;
+import java.util.List;
+import javax.servlet.http.HttpServletResponse;
+import org.eclipse.jetty.server.Response;
+
+public class JettyResponseAPIData implements ResponseAPIData {
+
+ private final Response response;
+ private final HttpServletResponse httpServletResponse;
+
+ public JettyResponseAPIData(Response response, HttpServletResponse httpServletResponse) {
+ this.response = response;
+ this.httpServletResponse = httpServletResponse;
+ }
+
+ public Response getResponse() {
+ return response;
+ }
+
+ public HttpServletResponse getHttpServletResponse() {
+ return httpServletResponse;
+ }
+
+ @Override
+ public void addAppLog(AppLogsPb.AppLogLine logLine) {}
+
+ @Override
+ public int getAppLogCount() {
+ return 0;
+ }
+
+ @Override
+ public List getAndClearAppLogList() {
+ return ImmutableList.of();
+ }
+
+ @Override
+ public void setSerializedTrace(ByteString byteString) {}
+
+ @Override
+ public void setTerminateClone(boolean terminateClone) {}
+
+ @Override
+ public void setCloneIsInUncleanState(boolean b) {}
+
+ @Override
+ public void setUserMcycles(long l) {}
+
+ @Override
+ public void addAllRuntimeLogLine(Collection logLines) {}
+
+ @Override
+ public void error(int error, String errorMessage) {}
+
+ @Override
+ public void finishWithResponse(AnyRpcServerContext rpc) {}
+
+ @Override
+ public void complete() {}
+
+ @Override
+ public int getError() {
+ return 0;
+ }
+}
diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyServletEngineAdapter.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyServletEngineAdapter.java
index b1b205310..718e7b7ac 100644
--- a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyServletEngineAdapter.java
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/JettyServletEngineAdapter.java
@@ -16,15 +16,21 @@
package com.google.apphosting.runtime.jetty9;
+import static com.google.apphosting.runtime.AppEngineConstants.HTTP_CONNECTOR_MODE;
+import static com.google.apphosting.runtime.AppEngineConstants.IGNORE_RESPONSE_SIZE_LIMIT;
import static java.nio.charset.StandardCharsets.UTF_8;
import com.google.apphosting.base.AppVersionKey;
import com.google.apphosting.base.protos.AppinfoPb;
+import com.google.apphosting.base.protos.EmptyMessage;
import com.google.apphosting.base.protos.RuntimePb.UPRequest;
import com.google.apphosting.base.protos.RuntimePb.UPResponse;
import com.google.apphosting.runtime.AppVersion;
+import com.google.apphosting.runtime.LocalRpcContext;
import com.google.apphosting.runtime.MutableUpResponse;
import com.google.apphosting.runtime.ServletEngineAdapter;
+import com.google.apphosting.runtime.SessionStoreFactory;
+import com.google.apphosting.runtime.anyrpc.EvaluationRuntimeServerInterface;
import com.google.apphosting.utils.config.AppEngineConfigException;
import com.google.apphosting.utils.config.AppYaml;
import com.google.common.flogger.GoogleLogger;
@@ -37,13 +43,14 @@
import java.util.Optional;
import javax.servlet.ServletException;
import org.eclipse.jetty.server.Connector;
+import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.handler.SizeLimitHandler;
import org.eclipse.jetty.util.thread.QueuedThreadPool;
/**
* This is an implementation of ServletEngineAdapter that uses the third-party Jetty servlet engine.
- *
*/
public class JettyServletEngineAdapter implements ServletEngineAdapter {
private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
@@ -89,7 +96,8 @@ private static AppYaml getAppYaml(ServletEngineAdapter.Config runtimeOptions) {
try {
appYaml = AppYaml.parse(new InputStreamReader(new FileInputStream(appYamlFile), UTF_8));
} catch (FileNotFoundException | AppEngineConfigException e) {
- logger.atWarning().log("Failed to load app.yaml file at location %s - %s",
+ logger.atWarning().log(
+ "Failed to load app.yaml file at location %s - %s",
appYamlFile.getPath(), e.getMessage());
}
return appYaml;
@@ -102,10 +110,11 @@ public void start(String serverInfo, ServletEngineAdapter.Config runtimeOptions)
server.setConnectors(new Connector[] {rpcConnector});
AppVersionHandlerFactory appVersionHandlerFactory =
new AppVersionHandlerFactory(
- server, serverInfo, contextFactory, /*useJettyErrorPageHandler=*/ false);
+ server, serverInfo, contextFactory, /* useJettyErrorPageHandler= */ false);
appVersionHandlerMap = new AppVersionHandlerMap(appVersionHandlerFactory);
- if (!"java8".equals(System.getenv("GAE_RUNTIME"))) {
+ if (!Objects.equals(System.getenv("GAE_RUNTIME"), "java8")
+ && !Boolean.getBoolean(IGNORE_RESPONSE_SIZE_LIMIT)) {
SizeLimitHandler sizeLimitHandler = new SizeLimitHandler(-1, MAX_RESPONSE_SIZE);
sizeLimitHandler.setHandler(appVersionHandlerMap);
server.setHandler(sizeLimitHandler);
@@ -113,19 +122,57 @@ public void start(String serverInfo, ServletEngineAdapter.Config runtimeOptions)
server.setHandler(appVersionHandlerMap);
}
- if (runtimeOptions.useJettyHttpProxy()) {
- server.setAttribute(
- "com.google.apphosting.runtime.jetty9.appYaml",
- appYaml.orElseGet(() -> JettyServletEngineAdapter.getAppYaml(runtimeOptions)));
- JettyHttpProxy.startServer(runtimeOptions);
- }
-
try {
- server.start();
- } catch (Exception ex) {
- // TODO: Should we have a wrapper exception for this
- // type of thing in ServletEngineAdapter?
- throw new RuntimeException(ex);
+ boolean startJettyHttpProxy = false;
+ if (runtimeOptions.useJettyHttpProxy()) {
+ AppVersionKey appVersionKey;
+ /* The init actions are not done in the constructor as they are not used when testing */
+ String appRoot = runtimeOptions.applicationRoot();
+ String appPath = runtimeOptions.fixedApplicationPath();
+ AppInfoFactory appInfoFactory = new AppInfoFactory(System.getenv());
+ AppinfoPb.AppInfo appinfo = appInfoFactory.getAppInfoFromFile(appRoot, appPath);
+ // TODO Should we also call ApplyCloneSettings()?
+ LocalRpcContext context = new LocalRpcContext<>(EmptyMessage.class);
+ EvaluationRuntimeServerInterface evaluationRuntimeServerInterface =
+ Objects.requireNonNull(runtimeOptions.evaluationRuntimeServerInterface());
+ evaluationRuntimeServerInterface.addAppVersion(context, appinfo);
+ EmptyMessage unused = context.getResponse();
+
+ if (Boolean.getBoolean(HTTP_CONNECTOR_MODE)) {
+ logger.atInfo().log("Using HTTP_CONNECTOR_MODE to bypass RPC");
+ appVersionKey = AppVersionKey.fromAppInfo(appinfo);
+ Handler unused2 = appVersionHandlerMap.getHandler(appVersionKey);
+ JettyHttpProxy.insertHandlers(server);
+ AppVersion appVersion = appVersionHandlerMap.getAppVersion(appVersionKey);
+ server.insertHandler(
+ new JettyHttpHandler(runtimeOptions, appVersion, appVersionKey, appInfoFactory));
+ ServerConnector connector = JettyHttpProxy.newConnector(server, runtimeOptions);
+ server.addConnector(connector);
+ } else {
+ server.setAttribute(
+ "com.google.apphosting.runtime.jetty9.appYaml",
+ appYaml.orElseGet(() -> JettyServletEngineAdapter.getAppYaml(runtimeOptions)));
+ // Delay start of JettyHttpProxy until after the main server and application is started.
+ startJettyHttpProxy = true;
+ }
+ }
+
+ ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader();
+ Thread.currentThread()
+ .setContextClassLoader(JettyServletEngineAdapter.class.getClassLoader());
+ try {
+ server.start();
+ if (startJettyHttpProxy) {
+ JettyHttpProxy.startServer(runtimeOptions);
+ }
+ } finally {
+ Thread.currentThread().setContextClassLoader(oldContextClassLoader);
+ }
+ } catch (Exception e) {
+ if (e instanceof InterruptedException) {
+ Thread.currentThread().interrupt();
+ }
+ throw new IllegalStateException(e);
}
}
@@ -152,10 +199,10 @@ public void deleteAppVersion(AppVersion appVersion) {
* Sets the {@link com.google.apphosting.runtime.SessionStoreFactory} that will be used to create
* the list of {@link com.google.apphosting.runtime.SessionStore SessionStores} to which the HTTP
* Session will be stored, if sessions are enabled. This method must be invoked after {@link
- * #start(String)}.
+ * #start(String, Config)}.
*/
@Override
- public void setSessionStoreFactory(com.google.apphosting.runtime.SessionStoreFactory factory) {
+ public void setSessionStoreFactory(SessionStoreFactory factory) {
appVersionHandlerMap.setSessionStoreFactory(factory);
}
diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/ResourceFileServlet.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/ResourceFileServlet.java
index 68bddac18..6cea7c23e 100644
--- a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/ResourceFileServlet.java
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/ResourceFileServlet.java
@@ -17,7 +17,7 @@
package com.google.apphosting.runtime.jetty9;
import com.google.apphosting.runtime.AppVersion;
-import com.google.apphosting.runtime.JettyConstants;
+import com.google.apphosting.runtime.AppEngineConstants;
import com.google.apphosting.utils.config.AppYaml;
import com.google.common.base.Ascii;
import com.google.common.flogger.GoogleLogger;
@@ -68,11 +68,11 @@ public class ResourceFileServlet extends HttpServlet {
public void init() throws ServletException {
context = getServletContext();
AppVersion appVersion =
- (AppVersion) context.getAttribute(JettyConstants.APP_VERSION_CONTEXT_ATTR);
+ (AppVersion) context.getAttribute(AppEngineConstants.APP_VERSION_CONTEXT_ATTR);
chandler = ((ContextHandler.Context) context).getContextHandler();
AppYaml appYaml =
- (AppYaml) chandler.getServer().getAttribute(JettyConstants.APP_YAML_ATTRIBUTE_TARGET);
+ (AppYaml) chandler.getServer().getAttribute(AppEngineConstants.APP_YAML_ATTRIBUTE_TARGET);
fSender = new FileSender(appYaml);
// AFAICT, there is no real API to retrieve this information, so
// we access Jetty's internal state.
@@ -250,7 +250,7 @@ private boolean maybeServeWelcomeFile(
}
AppVersion appVersion =
- (AppVersion) getServletContext().getAttribute(JettyConstants.APP_VERSION_CONTEXT_ATTR);
+ (AppVersion) getServletContext().getAttribute(AppEngineConstants.APP_VERSION_CONTEXT_ATTR);
ServletHandler handler = chandler.getChildHandlerByClass(ServletHandler.class);
MappedResource defaultEntry = handler.getHolderEntry("/");
diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/RpcConnection.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/RpcConnection.java
index ad5c18ac6..e69f7797d 100644
--- a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/RpcConnection.java
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/RpcConnection.java
@@ -21,7 +21,7 @@
import com.google.apphosting.base.protos.HttpPb.ParsedHttpHeader;
import com.google.apphosting.base.protos.RuntimePb.UPRequest;
import com.google.apphosting.base.protos.RuntimePb.UPResponse;
-import com.google.apphosting.runtime.JettyConstants;
+import com.google.apphosting.runtime.AppEngineConstants;
import com.google.apphosting.runtime.MutableUpResponse;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Ascii;
@@ -245,7 +245,7 @@ public void onCompleted() {
// Tell AppVersionHandlerMap which app version should handle this
// request.
- request.setAttribute(JettyConstants.APP_VERSION_KEY_REQUEST_ATTR, appVersionKey);
+ request.setAttribute(AppEngineConstants.APP_VERSION_KEY_REQUEST_ATTR, appVersionKey);
final boolean skipAdmin = hasSkipAdminCheck(endPoint.getUpRequest());
// Translate the X-Google-Internal-SkipAdminCheck to a servlet attribute.
diff --git a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/UPRequestTranslator.java b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/UPRequestTranslator.java
index 4cdef9797..4673926df 100644
--- a/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/UPRequestTranslator.java
+++ b/runtime/runtime_impl_jetty9/src/main/java/com/google/apphosting/runtime/jetty9/UPRequestTranslator.java
@@ -16,6 +16,38 @@
package com.google.apphosting.runtime.jetty9;
+import static com.google.apphosting.runtime.AppEngineConstants.BACKGROUND_REQUEST_URL;
+import static com.google.apphosting.runtime.AppEngineConstants.IS_ADMIN_HEADER_VALUE;
+import static com.google.apphosting.runtime.AppEngineConstants.IS_TRUSTED;
+import static com.google.apphosting.runtime.AppEngineConstants.PRIVATE_APPENGINE_HEADERS;
+import static com.google.apphosting.runtime.AppEngineConstants.WARMUP_IP;
+import static com.google.apphosting.runtime.AppEngineConstants.WARMUP_REQUEST_URL;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_API_TICKET;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_APPSERVER_DATACENTER;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_APPSERVER_TASK_BNS;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_AUTH_DOMAIN;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_DEFAULT_VERSION_HOSTNAME;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_GAIA_AUTHUSER;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_GAIA_ID;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_GAIA_SESSION;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_HTTPS;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_LOAS_PEER_USERNAME;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_QUEUENAME;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_REQUEST_LOG_ID;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_TIMEOUT_MS;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_TRUSTED_IP_REQUEST;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_EMAIL;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_ID;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_IP;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_IS_ADMIN;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_NICKNAME;
+import static com.google.apphosting.runtime.AppEngineConstants.X_APPENGINE_USER_ORGANIZATION;
+import static com.google.apphosting.runtime.AppEngineConstants.X_CLOUD_TRACE_CONTEXT;
+import static com.google.apphosting.runtime.AppEngineConstants.X_FORWARDED_PROTO;
+import static com.google.apphosting.runtime.AppEngineConstants.X_GOOGLE_INTERNAL_PROFILER;
+import static com.google.apphosting.runtime.AppEngineConstants.X_GOOGLE_INTERNAL_SKIPADMINCHECK;
+import static com.google.apphosting.runtime.AppEngineConstants.X_GOOGLE_INTERNAL_SKIPADMINCHECK_UC;
+
import com.google.apphosting.base.protos.AppinfoPb;
import com.google.apphosting.base.protos.HttpPb;
import com.google.apphosting.base.protos.HttpPb.HttpRequest;
@@ -26,13 +58,13 @@
import com.google.apphosting.runtime.TraceContextHelper;
import com.google.common.base.Ascii;
import com.google.common.base.Strings;
-import com.google.common.collect.ImmutableSet;
import com.google.common.flogger.GoogleLogger;
import com.google.common.html.HtmlEscapers;
import com.google.protobuf.ByteString;
import com.google.protobuf.TextFormat;
import java.io.IOException;
import java.util.Collections;
+import java.util.Objects;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@@ -46,70 +78,6 @@ public class UPRequestTranslator {
private static final String DEFAULT_SECRET_KEY = "secretkey";
- /**
- * The HTTP headers that are handled specially by this proxy are defined in lowercae because HTTP
- * headers are case insensitive and we look then up in a set or switch after converting to
- * lower-case.
- */
- private static final String X_FORWARDED_PROTO = "x-forwarded-proto";
-
- private static final String X_APPENGINE_API_TICKET = "x-appengine-api-ticket";
- private static final String X_APPENGINE_HTTPS = "x-appengine-https";
- private static final String X_APPENGINE_USER_IP = "x-appengine-user-ip";
- private static final String X_APPENGINE_USER_EMAIL = "x-appengine-user-email";
- private static final String X_APPENGINE_AUTH_DOMAIN = "x-appengine-auth-domain";
- private static final String X_APPENGINE_USER_ID = "x-appengine-user-id";
- private static final String X_APPENGINE_USER_NICKNAME = "x-appengine-user-nickname";
- private static final String X_APPENGINE_USER_ORGANIZATION = "x-appengine-user-organization";
- private static final String X_APPENGINE_USER_IS_ADMIN = "x-appengine-user-is-admin";
- private static final String X_APPENGINE_TRUSTED_IP_REQUEST = "x-appengine-trusted-ip-request";
- private static final String X_APPENGINE_LOAS_PEER_USERNAME = "x-appengine-loas-peer-username";
- private static final String X_APPENGINE_GAIA_ID = "x-appengine-gaia-id";
- private static final String X_APPENGINE_GAIA_AUTHUSER = "x-appengine-gaia-authuser";
- private static final String X_APPENGINE_GAIA_SESSION = "x-appengine-gaia-session";
- private static final String X_APPENGINE_APPSERVER_DATACENTER = "x-appengine-appserver-datacenter";
- private static final String X_APPENGINE_APPSERVER_TASK_BNS = "x-appengine-appserver-task-bns";
- private static final String X_APPENGINE_DEFAULT_VERSION_HOSTNAME =
- "x-appengine-default-version-hostname";
- private static final String X_APPENGINE_REQUEST_LOG_ID = "x-appengine-request-log-id";
- private static final String X_APPENGINE_QUEUENAME = "x-appengine-queuename";
- private static final String X_APPENGINE_TIMEOUT_MS = "x-appengine-timeout-ms";
- private static final String X_GOOGLE_INTERNAL_SKIPADMINCHECK = "x-google-internal-skipadmincheck";
- private static final String X_GOOGLE_INTERNAL_SKIPADMINCHECK_UC =
- "X-Google-Internal-SkipAdminCheck";
- private static final String X_GOOGLE_INTERNAL_PROFILER = "x-google-internal-profiler";
- private static final String X_CLOUD_TRACE_CONTEXT = "x-cloud-trace-context";
-
- private static final String IS_ADMIN_HEADER_VALUE = "1";
- private static final String IS_TRUSTED = "1";
-
- // The impersonated IP address of warmup requests (and also background)
- // ()
- private static final String WARMUP_IP = "0.1.0.3";
-
- private static final ImmutableSet PRIVATE_APPENGINE_HEADERS =
- ImmutableSet.of(
- X_APPENGINE_API_TICKET,
- X_APPENGINE_HTTPS,
- X_APPENGINE_USER_IP,
- X_APPENGINE_USER_EMAIL,
- X_APPENGINE_AUTH_DOMAIN,
- X_APPENGINE_USER_ID,
- X_APPENGINE_USER_NICKNAME,
- X_APPENGINE_USER_ORGANIZATION,
- X_APPENGINE_USER_IS_ADMIN,
- X_APPENGINE_TRUSTED_IP_REQUEST,
- X_APPENGINE_LOAS_PEER_USERNAME,
- X_APPENGINE_GAIA_ID,
- X_APPENGINE_GAIA_AUTHUSER,
- X_APPENGINE_GAIA_SESSION,
- X_APPENGINE_APPSERVER_DATACENTER,
- X_APPENGINE_APPSERVER_TASK_BNS,
- X_APPENGINE_DEFAULT_VERSION_HOSTNAME,
- X_APPENGINE_REQUEST_LOG_ID,
- X_APPENGINE_TIMEOUT_MS,
- X_GOOGLE_INTERNAL_PROFILER);
-
private final AppInfoFactory appInfoFactory;
private final boolean passThroughPrivateHeaders;
private final boolean skipPostData;
@@ -230,12 +198,12 @@ public final RuntimePb.UPRequest translateRequest(HttpServletRequest realRequest
}
}
- if ("/_ah/background".equals(realRequest.getRequestURI())) {
- if (WARMUP_IP.equals(httpRequest.getUserIp())) {
+ if (Objects.equals(realRequest.getRequestURI(), BACKGROUND_REQUEST_URL)) {
+ if (Objects.equals(httpRequest.getUserIp(), WARMUP_IP)) {
upReqBuilder.setRequestType(UPRequest.RequestType.BACKGROUND);
}
- } else if ("/_ah/start".equals(realRequest.getRequestURI())) {
- if (WARMUP_IP.equals(httpRequest.getUserIp())) {
+ } else if (Objects.equals(realRequest.getRequestURI(), WARMUP_REQUEST_URL)) {
+ if (Objects.equals(httpRequest.getUserIp(), WARMUP_IP)) {
// This request came from within App Engine via secure internal channels; tell Jetty
// it's HTTPS to avoid 403 because of web.xml security-constraint checks.
httpRequest.setIsHttps(true);
diff --git a/runtime/test/pom.xml b/runtime/test/pom.xml
index eda026aea..e4c411510 100644
--- a/runtime/test/pom.xml
+++ b/runtime/test/pom.xml
@@ -22,7 +22,7 @@
com.google.appengine
runtime-parent
- 2.0.28-SNAPSHOT
+ 2.0.29-SNAPSHOT
jar
diff --git a/runtime/test/src/test/java/com/google/apphosting/runtime/jetty9/JavaRuntimeViaHttpBase.java b/runtime/test/src/test/java/com/google/apphosting/runtime/jetty9/JavaRuntimeViaHttpBase.java
index 03903e6ea..979a9c213 100644
--- a/runtime/test/src/test/java/com/google/apphosting/runtime/jetty9/JavaRuntimeViaHttpBase.java
+++ b/runtime/test/src/test/java/com/google/apphosting/runtime/jetty9/JavaRuntimeViaHttpBase.java
@@ -42,6 +42,7 @@
import com.google.common.reflect.ClassPath;
import com.google.common.reflect.ClassPath.ResourceInfo;
import com.google.common.reflect.Reflection;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.ForOverride;
import com.google.appengine.repackaged.com.google.protobuf.ByteString;
import com.google.appengine.repackaged.com.google.protobuf.ExtensionRegistry;
@@ -84,10 +85,12 @@ public abstract class JavaRuntimeViaHttpBase {
@ClassRule public static TemporaryFolder temporaryFolder = new TemporaryFolder();
private static final String RUNTIME_LOCATION_ROOT = "java/com/google/apphosting";
static final int RESPONSE_200 = 200;
+
@FunctionalInterface
interface ApiServerFactory {
ApiServerT newApiServer(int apiPort, int runtimePort) throws IOException;
}
+
static class RuntimeContext implements AutoCloseable {
private final Process runtimeProcess;
private final ApiServerT httpApiServer;
@@ -95,6 +98,7 @@ static class RuntimeContext implements AutoCloseab
private final int jettyPort;
private final OutputPump outPump;
private final OutputPump errPump;
+
private RuntimeContext(
Process runtimeProcess,
ApiServerT httpApiServer,
@@ -109,14 +113,19 @@ private RuntimeContext(
this.outPump = outPump;
this.errPump = errPump;
}
+
public int getPort() {
return jettyPort;
}
+
@AutoValue
abstract static class Config {
abstract ImmutableMap environmentEntries();
+
abstract ImmutableList launcherFlags();
+
abstract ApiServerFactory apiServerFactory();
+
// The default configuration uses an API server that rejects all API calls as unknown.
// Individual tests can configure a different server, including the HttpApiServer from the SDK
// which provides APIs using their dev app server implementations.
@@ -125,35 +134,42 @@ static Builder builder() {
(apiPort, runtimePort) -> DummyApiServer.create(apiPort, ImmutableMap.of());
return builder(apiServerFactory);
}
+
static Builder builder(
ApiServerFactory apiServerFactory) {
return new AutoValue_JavaRuntimeViaHttpBase_RuntimeContext_Config.Builder()
.setEnvironmentEntries(ImmutableMap.of())
.setApiServerFactory(apiServerFactory);
}
+
@AutoValue.Builder
abstract static class Builder {
private boolean applicationPath;
private boolean applicationRoot;
+
/**
* Sets the application path. In this approach, applicationPath is the complete application
* location.
*/
+ @CanIgnoreReturnValue
Builder setApplicationPath(String path) {
applicationPath = true;
launcherFlagsBuilder().add("--fixed_application_path=" + path);
return this;
}
+
/** Sets Jetty's max request header size. */
Builder setJettyRequestHeaderSize(int size) {
launcherFlagsBuilder().add("--jetty_request_header_size=" + size);
return this;
}
+
/** Sets Jetty's max response header size. */
Builder setJettyResponseHeaderSize(int size) {
launcherFlagsBuilder().add("--jetty_response_header_size=" + size);
return this;
}
+
/**
* Sets the application root. In this legacy case, you need to set the correct set of env
* variables for "GAE_APPLICATION", "GAE_VERSION", "GAE_DEPLOYMENT_ID" with a correct
@@ -168,10 +184,15 @@ Builder setApplicationRoot(String root) {
launcherFlagsBuilder().add("--application_root=" + root);
return this;
}
+
abstract Builder setEnvironmentEntries(ImmutableMap entries);
+
abstract ImmutableList.Builder launcherFlagsBuilder();
+
abstract Builder setApiServerFactory(ApiServerFactory factory);
+
abstract Config autoBuild();
+
Config build() {
if (applicationPath == applicationRoot) {
throw new IllegalStateException(
@@ -181,6 +202,7 @@ Config build() {
}
}
}
+
/** JVM flags needed for JDK above JDK8 */
private static ImmutableList optionalFlags() {
if (!JAVA_VERSION.value().startsWith("1.8")) {
@@ -197,6 +219,7 @@ private static ImmutableList optionalFlags() {
}
return ImmutableList.of("-showversion"); // Just so that the list is not empty.
}
+
static RuntimeContext create(
Config config) throws IOException, InterruptedException {
PortPicker portPicker = PortPicker.create();
@@ -212,11 +235,11 @@ static RuntimeContext create(
.isTrue();
InetSocketAddress apiSocketAddress = new InetSocketAddress(apiPort);
ImmutableList.Builder builder = ImmutableList.builder();
- builder.add(JAVA_HOME.value() + "/bin/java");
- Integer debugPort = Integer.getInteger("appengine.debug.port");
- if (debugPort != null) {
+ builder.add(JAVA_HOME.value() + "/bin/java");
+ Integer debugPort = Integer.getInteger("appengine.debug.port");
+ if (debugPort != null) {
builder.add("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:" + debugPort);
- }
+ }
ImmutableList runtimeArgs =
builder
.add(
@@ -225,6 +248,8 @@ static RuntimeContext create(
"-Dappengine.use.EE10=" + Boolean.getBoolean("appengine.use.EE10"),
"-Dappengine.use.HttpConnector="
+ Boolean.getBoolean("appengine.use.HttpConnector"),
+ "-Dappengine.ignore.responseSizeLimit="
+ + Boolean.getBoolean("appengine.ignore.responseSizeLimit"),
"-Djetty.server.dumpAfterStart="
+ Boolean.getBoolean("jetty.server.dumpAfterStart"),
"-Duse.mavenjars=" + useMavenJars(),
@@ -262,35 +287,41 @@ static RuntimeContext create(
return new RuntimeContext<>(
runtimeProcess, httpApiServer, httpClient, jettyPort, outPump, errPump);
}
+
public static boolean isPortAvailable(String host, int port) {
- try {
- Socket socket = new Socket(host, port);
- socket.close();
- return true;
- } catch (Exception e) {
- return false;
- }
+ try {
+ try (Socket socket = new Socket(host, port)) {}
+ return true;
+ } catch (Exception e) {
+ return false;
+ }
}
+
private static List jvmFlagsFromEnvironment(ImmutableMap env) {
return Splitter.on(' ').omitEmptyStrings().splitToList(env.getOrDefault("GAE_JAVA_OPTS", ""));
}
+
ApiServerT getApiServer() {
return httpApiServer;
}
+
HttpClient getHttpClient() {
return httpClient;
}
+
String jettyUrl(String urlPath) {
return String.format(
"http://%s%s",
HostAndPort.fromParts(new InetSocketAddress(jettyPort).getHostString(), jettyPort),
urlPath);
}
+
void executeHttpGet(String url, String expectedResponseBody, int expectedReturnCode)
throws Exception {
executeHttpGetWithRetries(
url, expectedResponseBody, expectedReturnCode, /* numberOfRetries= */ 1);
}
+
String executeHttpGet(String urlPath, int expectedReturnCode) throws Exception {
HttpGet get = new HttpGet(jettyUrl(urlPath));
HttpResponse response = httpClient.execute(get);
@@ -306,6 +337,7 @@ String executeHttpGet(String urlPath, int expectedReturnCode) throws Exception {
EntityUtils.consumeQuietly(entity);
}
}
+
void executeHttpGetWithRetries(
String urlPath, String expectedResponse, int expectedReturnCode, int numberOfRetries)
throws Exception {
@@ -324,12 +356,15 @@ void executeHttpGetWithRetries(
assertThat(content).isEqualTo(expectedResponse);
assertThat(retCode).isEqualTo(expectedReturnCode);
}
+
void awaitStdoutLineMatching(String pattern, long timeoutSeconds) throws InterruptedException {
outPump.awaitOutputLineMatching(pattern, timeoutSeconds);
}
+
void awaitStderrLineMatching(String pattern, long timeoutSeconds) throws InterruptedException {
errPump.awaitOutputLineMatching(pattern, timeoutSeconds);
}
+
private static Process launchRuntime(
ImmutableList args, ImmutableMap environmentEntries)
throws IOException {
@@ -337,29 +372,36 @@ private static Process launchRuntime(
pb.environment().putAll(environmentEntries);
return pb.start();
}
+
Process runtimeProcess() {
return runtimeProcess;
}
+
@Override
public void close() throws IOException {
runtimeProcess.destroy();
httpApiServer.close();
}
}
+
static boolean useMavenJars() {
return Boolean.getBoolean("use.mavenjars");
}
+
static boolean useJetty94LegacyMode() {
return Boolean.getBoolean("com.google.apphosting.runtime.jetty94.LEGACY_MODE");
}
+
static class OutputPump implements Runnable {
private final BufferedReader stream;
private final String echoPrefix;
private final BlockingQueue outputQueue = new LinkedBlockingQueue<>();
+
OutputPump(InputStream instream, String echoPrefix) {
this.stream = new BufferedReader(new InputStreamReader(instream, UTF_8));
this.echoPrefix = echoPrefix;
}
+
@Override
public void run() {
String line;
@@ -372,6 +414,7 @@ public void run() {
throw new RuntimeException(e);
}
}
+
void awaitOutputLineMatching(String pattern, long timeoutSeconds) throws InterruptedException {
long timeoutMillis = MILLISECONDS.convert(timeoutSeconds, SECONDS);
long deadline = System.currentTimeMillis() + timeoutMillis;
@@ -387,8 +430,10 @@ void awaitOutputLineMatching(String pattern, long timeoutSeconds) throws Interru
}
}
}
+
private static final Pattern JAR_URL_PATTERN = Pattern.compile("jar:file:(.*)!(.*)");
private static final Pattern JAR_FILE_URL_PATTERN = Pattern.compile("file:(.*\\.jar)");
+
/**
* Extract the test app with the given name into the given output directory. The situation is that
* we have a jar file in our classpath that contains this app, plus maybe a bunch of other stuff.
@@ -448,6 +493,7 @@ static void copyAppToDir(String appName, Path dir) throws IOException {
}
}
}
+
private static void copyJarContainingClass(String className, Path toPath) throws IOException {
try {
Class threadManager = Class.forName(className);
@@ -469,6 +515,7 @@ private static void copyJarContainingClass(String className, Path toPath) throws
// OK: the app presumably doesn't need this.
}
}
+
/**
* An API server that handles API calls via the supplied handler map. Each incoming API call is
* looked up as {@code service.method}, for example {@code urlfetch.Fetch}, to discover a
@@ -480,11 +527,13 @@ private static void copyJarContainingClass(String className, Path toPath) throws
*/
static class DummyApiServer implements Closeable {
private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
+
static DummyApiServer create(
int apiPort, ImmutableMap> handlerMap)
throws IOException {
return create(apiPort, handlerMap, request -> {});
}
+
static DummyApiServer create(
int apiPort,
ImmutableMap> handlerMap,
@@ -498,13 +547,16 @@ static DummyApiServer create(
httpServer.start();
return apiServer;
}
+
private final HttpServer httpServer;
private final Function> handlerLookup;
private final Consumer requestObserver;
+
DummyApiServer(
HttpServer httpServer, Function> handlerLookup) {
this(httpServer, handlerLookup, request -> {});
}
+
private DummyApiServer(
HttpServer httpServer,
Function> handlerLookup,
@@ -513,14 +565,17 @@ private DummyApiServer(
this.handlerLookup = handlerLookup;
this.requestObserver = requestObserver;
}
+
@Override
public void close() {
httpServer.stop(0);
}
+
@ForOverride
RemoteApiPb.Response.Builder newResponseBuilder() {
return RemoteApiPb.Response.newBuilder();
}
+
void handle(HttpExchange exchange) throws IOException {
try (InputStream in = exchange.getRequestBody();
OutputStream out = exchange.getResponseBody()) {
diff --git a/runtime/test/src/test/java/com/google/apphosting/runtime/jetty9/SizeLimitIgnoreTest.java b/runtime/test/src/test/java/com/google/apphosting/runtime/jetty9/SizeLimitIgnoreTest.java
new file mode 100644
index 000000000..d02973cda
--- /dev/null
+++ b/runtime/test/src/test/java/com/google/apphosting/runtime/jetty9/SizeLimitIgnoreTest.java
@@ -0,0 +1,370 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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
+ *
+ * https://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.apphosting.runtime.jetty9;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.lessThan;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.zip.GZIPOutputStream;
+import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.api.ContentProvider;
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.client.api.Response;
+import org.eclipse.jetty.client.api.Result;
+import org.eclipse.jetty.client.util.ByteBufferContentProvider;
+import org.eclipse.jetty.client.util.DeferredContentProvider;
+import org.eclipse.jetty.client.util.InputStreamContentProvider;
+import org.eclipse.jetty.http.HttpHeader;
+import org.eclipse.jetty.http.HttpStatus;
+import org.eclipse.jetty.util.BufferUtil;
+import org.eclipse.jetty.util.Utf8StringBuilder;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class SizeLimitIgnoreTest extends JavaRuntimeViaHttpBase {
+ @Parameterized.Parameters
+ public static List data() {
+ return Arrays.asList(
+ new Object[][] {
+ {"jetty94", false},
+ {"ee8", false},
+ {"ee10", false},
+ {"ee8", true},
+ {"ee10", true},
+ });
+ }
+
+ private static final int MAX_SIZE = 32 * 1024 * 1024;
+ @Rule public TemporaryFolder temp = new TemporaryFolder();
+ private final HttpClient httpClient = new HttpClient();
+ private final boolean httpMode;
+ private final String environment;
+ private RuntimeContext runtime;
+
+ public SizeLimitIgnoreTest(String environment, boolean httpMode) {
+ this.environment = environment;
+ this.httpMode = httpMode;
+ System.setProperty("appengine.use.HttpConnector", Boolean.toString(httpMode));
+ System.setProperty("appengine.ignore.responseSizeLimit", "true");
+ }
+
+ @Before
+ public void before() throws Exception {
+ String app = "sizelimit" + environment;
+ copyAppToDir(app, temp.getRoot().toPath());
+ httpClient.start();
+ runtime = runtimeContext();
+ assertEnvironment();
+ System.err.println("==== Using Environment: " + environment + " " + httpMode + " ====");
+ }
+
+ @After
+ public void after() throws Exception {
+ httpClient.stop();
+ runtime.close();
+ }
+
+ @Test
+ public void testResponseContentBelowMaxLength() throws Exception {
+ long contentLength = MAX_SIZE;
+ String url = runtime.jettyUrl("/?size=" + contentLength);
+ CompletableFuture completionListener = new CompletableFuture<>();
+ AtomicLong contentReceived = new AtomicLong();
+ httpClient
+ .newRequest(url)
+ .onResponseContentAsync(
+ (response, content, callback) -> {
+ contentReceived.addAndGet(content.remaining());
+ callback.succeeded();
+ })
+ .header("setCustomHeader", "true")
+ .send(completionListener::complete);
+
+ Result result = completionListener.get(5, TimeUnit.SECONDS);
+ assertThat(result.getResponse().getStatus(), equalTo(HttpStatus.OK_200));
+ assertThat(contentReceived.get(), equalTo(contentLength));
+ assertThat(result.getResponse().getHeaders().get("custom-header"), equalTo("true"));
+ }
+
+ @Test
+ public void testResponseContentAboveMaxLength() throws Exception {
+ long contentLength = MAX_SIZE + 1;
+ String url = runtime.jettyUrl("/?size=" + contentLength);
+ CompletableFuture completionListener = new CompletableFuture<>();
+ AtomicLong contentReceived = new AtomicLong();
+ httpClient
+ .newRequest(url)
+ .onResponseContentAsync(
+ (response, content, callback) -> {
+ contentReceived.addAndGet(content.remaining());
+ callback.succeeded();
+ })
+ .header("setCustomHeader", "true")
+ .send(completionListener::complete);
+
+ Result result = completionListener.get(5, TimeUnit.SECONDS);
+ assertThat(result.getResponse().getStatus(), equalTo(HttpStatus.OK_200));
+ assertThat(contentReceived.get(), equalTo(contentLength));
+ assertThat(result.getResponse().getHeaders().get("custom-header"), equalTo("true"));
+ }
+
+ @Test
+ public void testResponseContentBelowMaxLengthGzip() throws Exception {
+ long contentLength = MAX_SIZE;
+ String url = runtime.jettyUrl("/?size=" + contentLength);
+ CompletableFuture completionListener = new CompletableFuture<>();
+ AtomicLong contentReceived = new AtomicLong();
+ httpClient.getContentDecoderFactories().clear();
+ httpClient
+ .newRequest(url)
+ .onResponseContentAsync(
+ (response, content, callback) -> {
+ contentReceived.addAndGet(content.remaining());
+ callback.succeeded();
+ })
+ .header(HttpHeader.ACCEPT_ENCODING, "gzip")
+ .send(completionListener::complete);
+
+ Result result = completionListener.get(5, TimeUnit.SECONDS);
+ assertThat(result.getResponse().getHeaders().get(HttpHeader.CONTENT_ENCODING), equalTo("gzip"));
+ assertThat(result.getResponse().getStatus(), equalTo(HttpStatus.OK_200));
+ assertThat(contentReceived.get(), lessThan(contentLength));
+ }
+
+ @Test
+ public void testResponseContentAboveMaxLengthGzip() throws Exception {
+ long contentLength = MAX_SIZE + 1;
+ String url = runtime.jettyUrl("/?size=" + contentLength);
+ CompletableFuture completionListener = new CompletableFuture<>();
+ AtomicLong contentReceived = new AtomicLong();
+ httpClient.getContentDecoderFactories().clear();
+ httpClient
+ .newRequest(url)
+ .onResponseContentAsync(
+ (response, content, callback) -> {
+ contentReceived.addAndGet(content.remaining());
+ callback.succeeded();
+ })
+ .header(HttpHeader.ACCEPT_ENCODING, "gzip")
+ .send(completionListener::complete);
+
+ Result result = completionListener.get(5, TimeUnit.SECONDS);
+ assertThat(result.getResponse().getHeaders().get(HttpHeader.CONTENT_ENCODING), equalTo("gzip"));
+ assertThat(result.getResponse().getStatus(), equalTo(HttpStatus.OK_200));
+ assertThat(contentReceived.get(), lessThan(contentLength));
+ }
+
+ @Test
+ public void testRequestContentBelowMaxLength() throws Exception {
+ int contentLength = MAX_SIZE;
+
+ byte[] data = new byte[contentLength];
+ Arrays.fill(data, (byte) 'X');
+ ContentProvider content = new ByteBufferContentProvider(BufferUtil.toBuffer(data));
+ String url = runtime.jettyUrl("/");
+ ContentResponse response = httpClient.newRequest(url).content(content).send();
+
+ assertThat(response.getStatus(), equalTo(HttpStatus.OK_200));
+ assertThat(
+ response.getContentAsString(), containsString("RequestContentLength: " + contentLength));
+ }
+
+ @Test
+ public void testRequestContentAboveMaxLength() throws Exception {
+ int contentLength = MAX_SIZE + 1;
+
+ CompletableFuture completionListener = new CompletableFuture<>();
+ byte[] data = new byte[contentLength];
+ Arrays.fill(data, (byte) 'X');
+ Utf8StringBuilder received = new Utf8StringBuilder();
+ ContentProvider content = new ByteBufferContentProvider(BufferUtil.toBuffer(data));
+ String url = runtime.jettyUrl("/");
+ httpClient
+ .newRequest(url)
+ .content(content)
+ .onResponseContentAsync(
+ (response, content1, callback) -> {
+ received.append(content1);
+ callback.succeeded();
+ })
+ .send(completionListener::complete);
+
+ Result result = completionListener.get(5, TimeUnit.SECONDS);
+ assertThat(result.getResponse().getStatus(), equalTo(HttpStatus.PAYLOAD_TOO_LARGE_413));
+
+ // If there is no Content-Length header the SizeLimitHandler fails the response as well.
+ if (result.getResponseFailure() == null) {
+ assertThat(received.toString(), containsString("Request body is too large"));
+ }
+ }
+
+ @Test
+ public void testRequestContentBelowMaxLengthGzip() throws Exception {
+ int contentLength = MAX_SIZE;
+
+ CompletableFuture completionListener = new CompletableFuture<>();
+ byte[] data = new byte[contentLength];
+ Arrays.fill(data, (byte) 'X');
+ Utf8StringBuilder received = new Utf8StringBuilder();
+ ContentProvider content = new InputStreamContentProvider(gzip(data));
+
+ String url = runtime.jettyUrl("/");
+ httpClient
+ .newRequest(url)
+ .content(content)
+ .onResponseContentAsync(
+ (response, content1, callback) -> {
+ received.append(content1);
+ callback.succeeded();
+ })
+ .header(HttpHeader.CONTENT_ENCODING, "gzip")
+ .send(completionListener::complete);
+
+ Result result = completionListener.get(5, TimeUnit.SECONDS);
+ assertThat(result.getResponse().getStatus(), equalTo(HttpStatus.OK_200));
+ assertThat(received.toString(), containsString("RequestContentLength: " + contentLength));
+ }
+
+ @Test
+ public void testRequestContentAboveMaxLengthGzip() throws Exception {
+ int contentLength = MAX_SIZE + 1;
+
+ CompletableFuture completionListener = new CompletableFuture<>();
+ byte[] data = new byte[contentLength];
+ Arrays.fill(data, (byte) 'X');
+ Utf8StringBuilder received = new Utf8StringBuilder();
+ ContentProvider content = new InputStreamContentProvider(gzip(data));
+
+ String url = runtime.jettyUrl("/");
+ httpClient
+ .newRequest(url)
+ .content(content)
+ .onResponseContentAsync(
+ (response, content1, callback) -> {
+ received.append(content1);
+ callback.succeeded();
+ })
+ .header(HttpHeader.CONTENT_ENCODING, "gzip")
+ .send(completionListener::complete);
+
+ Result result = completionListener.get(5, TimeUnit.SECONDS);
+ assertThat(result.getResponse().getStatus(), equalTo(HttpStatus.PAYLOAD_TOO_LARGE_413));
+
+ // If there is no Content-Length header the SizeLimitHandler fails the response as well.
+ if (result.getResponseFailure() == null) {
+ assertThat(received.toString(), containsString("Request body is too large"));
+ }
+ }
+
+ @Test
+ public void testResponseContentLengthHeader() throws Exception {
+ long contentLength = MAX_SIZE + 1;
+ String url = runtime.jettyUrl("/?setContentLength=" + contentLength);
+ httpClient.getContentDecoderFactories().clear();
+ ContentResponse response = httpClient.newRequest(url).send();
+
+ assertThat(response.getStatus(), equalTo(HttpStatus.INTERNAL_SERVER_ERROR_500));
+
+ // No content is sent on the Jetty 9.4 runtime.
+ if (!Objects.equals(environment, "jetty94")) {
+ assertThat(response.getContentAsString(), containsString("IllegalStateException"));
+ }
+ }
+
+ @Test
+ public void testRequestContentLengthHeader() throws Exception {
+ CompletableFuture completionListener = new CompletableFuture<>();
+ DeferredContentProvider provider = new DeferredContentProvider(ByteBuffer.allocate(1));
+ int contentLength = MAX_SIZE + 1;
+ String url = runtime.jettyUrl("/");
+ Utf8StringBuilder received = new Utf8StringBuilder();
+ httpClient
+ .newRequest(url)
+ .header(HttpHeader.CONTENT_LENGTH, Long.toString(contentLength))
+ .header("foo", "bar")
+ .content(provider)
+ .onResponseContentAsync(
+ (response, content, callback) -> {
+ received.append(content);
+ callback.succeeded();
+ provider.close();
+ })
+ .send(completionListener::complete);
+
+ Result result = completionListener.get(5, TimeUnit.SECONDS);
+ Response response = result.getResponse();
+ assertThat(response.getStatus(), equalTo(HttpStatus.PAYLOAD_TOO_LARGE_413));
+
+ // If there is no Content-Length header the SizeLimitHandler fails the response as well.
+ if (result.getResponseFailure() == null) {
+ assertThat(received.toString(), containsString("Request body is too large"));
+ }
+ }
+
+ private RuntimeContext runtimeContext() throws Exception {
+ RuntimeContext.Config config =
+ RuntimeContext.Config.builder().setApplicationPath(temp.getRoot().toString()).build();
+ return RuntimeContext.create(config);
+ }
+
+ private void assertEnvironment() throws Exception {
+ String match;
+ switch (environment) {
+ case "jetty94":
+ match = "org.eclipse.jetty.server.Request";
+ break;
+ case "ee8":
+ match = "org.eclipse.jetty.ee8";
+ break;
+ case "ee10":
+ match = "org.eclipse.jetty.ee10";
+ break;
+ default:
+ throw new IllegalArgumentException(environment);
+ }
+
+ String runtimeUrl = runtime.jettyUrl("/?getRequestClass=true");
+ ContentResponse response = httpClient.GET(runtimeUrl);
+ assertThat(response.getContentAsString(), containsString(match));
+ }
+
+ private static InputStream gzip(byte[] data) throws IOException {
+ ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ try (GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream)) {
+ gzipOutputStream.write(data);
+ }
+ return new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
+ }
+}
diff --git a/runtime/testapps/pom.xml b/runtime/testapps/pom.xml
index bf52e7696..834a2846b 100644
--- a/runtime/testapps/pom.xml
+++ b/runtime/testapps/pom.xml
@@ -22,7 +22,7 @@
com.google.appengine
runtime-parent
- 2.0.28-SNAPSHOT
+ 2.0.29-SNAPSHOT
jar
diff --git a/runtime/util/pom.xml b/runtime/util/pom.xml
index c4ddcac05..d867bc722 100644
--- a/runtime/util/pom.xml
+++ b/runtime/util/pom.xml
@@ -22,7 +22,7 @@
com.google.appengine
runtime-parent
- 2.0.28-SNAPSHOT
+ 2.0.29-SNAPSHOT
jar
diff --git a/runtime_shared/pom.xml b/runtime_shared/pom.xml
index 815ec9b3c..6c488a1a2 100644
--- a/runtime_shared/pom.xml
+++ b/runtime_shared/pom.xml
@@ -22,7 +22,7 @@
com.google.appengine
parent
- 2.0.28-SNAPSHOT
+ 2.0.29-SNAPSHOT
jar
diff --git a/runtime_shared_jetty12/pom.xml b/runtime_shared_jetty12/pom.xml
index 6ad5ed832..fec0b0152 100644
--- a/runtime_shared_jetty12/pom.xml
+++ b/runtime_shared_jetty12/pom.xml
@@ -22,7 +22,7 @@
com.google.appengine
parent
- 2.0.28-SNAPSHOT
+ 2.0.29-SNAPSHOT
jar
diff --git a/runtime_shared_jetty12_ee10/pom.xml b/runtime_shared_jetty12_ee10/pom.xml
index da43d0e33..123cd5b43 100644
--- a/runtime_shared_jetty12_ee10/pom.xml
+++ b/runtime_shared_jetty12_ee10/pom.xml
@@ -22,7 +22,7 @@
com.google.appengine
parent
- 2.0.28-SNAPSHOT
+ 2.0.29-SNAPSHOT
jar
diff --git a/runtime_shared_jetty9/pom.xml b/runtime_shared_jetty9/pom.xml
index d74fd5693..e0ebea442 100644
--- a/runtime_shared_jetty9/pom.xml
+++ b/runtime_shared_jetty9/pom.xml
@@ -22,7 +22,7 @@
com.google.appengine
parent
- 2.0.28-SNAPSHOT
+ 2.0.29-SNAPSHOT
jar
diff --git a/sdk_assembly/pom.xml b/sdk_assembly/pom.xml
index 4dc83b389..78c501f8d 100644
--- a/sdk_assembly/pom.xml
+++ b/sdk_assembly/pom.xml
@@ -20,7 +20,7 @@
com.google.appengine
parent
- 2.0.28-SNAPSHOT
+ 2.0.29-SNAPSHOT
4.0.0
appengine-java-sdk
@@ -81,7 +81,7 @@