com.google.gwt.user.server.rpc.jakarta.AbstractRemoteServiceServlet Maven / Gradle / Ivy
/*
* Copyright 2009 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.user.server.rpc.jakarta;
import static com.google.gwt.user.client.rpc.RpcRequestBuilder.STRONG_NAME_HEADER;
import java.io.IOException;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import com.google.gwt.user.server.rpc.*;
/**
* An abstract base class containing utility methods.
*/
public abstract class AbstractRemoteServiceServlet extends HttpServlet {
protected transient ThreadLocal perThreadRequest;
protected transient ThreadLocal perThreadResponse;
public AbstractRemoteServiceServlet() {
super();
}
/**
* Standard HttpServlet method: handle the POST. Delegates to
* {@link #processPost(HttpServletRequest, HttpServletResponse)}.
*
* This doPost method swallows ALL exceptions, logs them in the
* ServletContext, and returns a GENERIC_FAILURE_MSG response with status code
* 500.
*/
@Override
public final void doPost(HttpServletRequest request,
HttpServletResponse response) {
// Ensure the thread-local data fields have been initialized
try {
// Store the request & response objects in thread-local storage.
//
synchronized (this) {
validateThreadLocalData();
perThreadRequest.set(request);
perThreadResponse.set(response);
}
processPost(request, response);
} catch (Throwable e) {
// Give a subclass a chance to either handle the exception or rethrow it
//
doUnexpectedFailure(e);
} finally {
// null the thread-locals to avoid holding request/response
//
perThreadRequest.set(null);
perThreadResponse.set(null);
}
}
/**
* Override this method to control what should happen when an exception
* escapes the {@link #doPost} method. The default implementation will log the
* failure and send a generic failure response to the client.
*
* An "expected failure" is an exception thrown by a service method that is
* declared in the signature of the service method. These exceptions are
* serialized back to the client, and are not passed to this method. This
* method is called only for exceptions or errors that are not part of the
* service method's signature, or that result from SecurityExceptions,
* SerializationExceptions, or other failures within the RPC framework.
*
* Note that if the desired behavior is to both send the GENERIC_FAILURE_MSG
* response AND to rethrow the exception, then this method should first send
* the GENERIC_FAILURE_MSG response itself (using getThreadLocalResponse), and
* then rethrow the exception. Rethrowing the exception will cause it to
* escape into the servlet container.
*
* @param e the exception which was thrown
*/
protected void doUnexpectedFailure(Throwable e) {
try {
getThreadLocalResponse().reset();
} catch (IllegalStateException ex) {
/*
* If we can't reset the request, the only way to signal that something
* has gone wrong is to throw an exception from here. It should be the
* case that we call the user's implementation code before emitting data
* into the response, so the only time that gets tripped is if the object
* serialization code blows up.
*/
throw new RuntimeException("Unable to report failure", e);
}
ServletContext servletContext = getServletContext();
RPCServletUtils.writeResponseForUnexpectedFailure(servletContext,
getThreadLocalResponse(), e);
}
/**
* Returns the strong name of the permutation, as reported by the client that
* issued the request, or null if it could not be determined.
* This information is encoded in the
* {@value com.google.gwt.user.client.rpc.RpcRequestBuilder#STRONG_NAME_HEADER}
* HTTP header.
*/
protected final String getPermutationStrongName() {
return getThreadLocalRequest().getHeader(STRONG_NAME_HEADER);
}
/**
* Gets the HttpServletRequest object for the current call. It is
* stored thread-locally so that simultaneous invocations can have different
* request objects.
*/
protected final HttpServletRequest getThreadLocalRequest() {
synchronized (this) {
validateThreadLocalData();
return perThreadRequest.get();
}
}
/**
* Gets the HttpServletResponse object for the current call. It
* is stored thread-locally so that simultaneous invocations can have
* different response objects.
*/
protected final HttpServletResponse getThreadLocalResponse() {
synchronized (this) {
validateThreadLocalData();
return perThreadResponse.get();
}
}
/**
* Override this method to examine the deserialized version of the request
* before the call to the servlet method is made. The default implementation
* does nothing and need not be called by subclasses.
*
* @param rpcRequest
*/
protected void onAfterRequestDeserialized(RPCRequest rpcRequest) {
}
/**
* Called by {@link #doPost} for type-specific processing of the request.
* Because doPost swallows all Throwables, this
* method may throw any exception the implementor wishes.
*/
protected abstract void processPost(HttpServletRequest request,
HttpServletResponse response) throws Throwable;
/**
* Override this method in order to control the parsing of the incoming
* request. For example, you may want to bypass the check of the Content-Type
* and character encoding headers in the request, as some proxies re-write the
* request headers. Note that bypassing these checks may expose the servlet to
* some cross-site vulnerabilities. Your implementation should comply with the
* HTTP/1.1 specification, which includes handling both requests which include
* a Content-Length header and requests utilizing Transfer-Encoding:
* chuncked.
*
* @param request the incoming request
* @return the content of the incoming request encoded as a string.
*/
protected String readContent(HttpServletRequest request)
throws ServletException, IOException {
return RPCServletUtils.readContentAsGwtRpc(request);
}
/**
* Initializes the perThreadRequest and perThreadResponse fields if they are
* null. This will occur the first time they are accessed after an instance of
* this class is constructed or deserialized. This method should be called
* from within a 'synchronized(this) {}' block in order to ensure that only
* one thread creates the objects.
*/
private void validateThreadLocalData() {
if (perThreadRequest == null) {
perThreadRequest = new ThreadLocal();
}
if (perThreadResponse == null) {
perThreadResponse = new ThreadLocal();
}
}
}