juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/BasicRestCallHandler.java - juneau - Git at Google

 // ***************************************************************************************************************************
 // * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements.  See the NOTICE file *
 // * distributed with this work for additional information regarding copyright ownership.  The ASF licenses this file        *
 // * to you 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 org.apache.juneau.rest;

 import static java.util.logging.Level.*;
 import static javax.servlet.http.HttpServletResponse.*;
 import static org.apache.juneau.internal.IOUtils.*;
 import static org.apache.juneau.internal.StringUtils.*;

 import java.io.*;
 import java.util.*;

 import javax.servlet.*;
 import javax.servlet.http.*;

 import org.apache.juneau.rest.annotation.*;
 import org.apache.juneau.rest.vars.*;

 /**
  * Default implementation of {@link RestCallHandler}.
  *
  * <p>
  * Subclasses can override these methods to tailor how HTTP REST calls are handled.
  * <br>Subclasses MUST implement a public constructor that takes in a {@link RestContext} object.
  *
  * <h5 class='section'>See Also:</h5>
  * <ul>
  * 	<li class='jf'>{@link RestContext#REST_callHandler}
  * </ul>
  */
 public class BasicRestCallHandler implements RestCallHandler {

 	private final RestContext context;
 	private final RestLogger logger;
 	private final Map<String,RestCallRouter> restCallRouters;

 	/**
 	 * Constructor.
 	 *
 	 * @param context The resource context.
 	 */
 	public BasicRestCallHandler(RestContext context) {
 		this.context = context;
 		this.logger = context.getLogger();
 		this.restCallRouters = context.getCallRouters();
 	}

 	/**
 	 * Creates a {@link RestRequest} object based on the specified incoming {@link HttpServletRequest} object.
 	 *
 	 * <p>
 	 * Subclasses may choose to override this method to provide a specialized request object.
 	 *
 	 * @param req The request object from the {@link #service(HttpServletRequest, HttpServletResponse)} method.
 	 * @return The wrapped request object.
 	 * @throws ServletException If any errors occur trying to interpret the request.
 	 */
 	@Override /* RestCallHandler */
 	public RestRequest createRequest(HttpServletRequest req) throws ServletException {
 		return new RestRequest(context, req);
 	}

 	/**
 	 * Creates a {@link RestResponse} object based on the specified incoming {@link HttpServletResponse} object
 	 * and the request returned by {@link #createRequest(HttpServletRequest)}.
 	 *
 	 * <p>
 	 * Subclasses may choose to override this method to provide a specialized response object.
 	 *
 	 * @param req The request object returned by {@link #createRequest(HttpServletRequest)}.
 	 * @param res The response object from the {@link #service(HttpServletRequest, HttpServletResponse)} method.
 	 * @return The wrapped response object.
 	 * @throws ServletException If any errors occur trying to interpret the request or response.
 	 */
 	@Override /* RestCallHandler */
 	public RestResponse createResponse(RestRequest req, HttpServletResponse res) throws ServletException {
 		return new RestResponse(context, req, res);
 	}

 	/**
 	 * The main service method.
 	 *
 	 * <p>
 	 * Subclasses can optionally override this method if they want to tailor the behavior of requests.
 	 *
 	 * @param r1 The incoming HTTP servlet request object.
 	 * @param r2 The incoming HTTP servlet response object.
 	 * @throws ServletException
 	 * @throws IOException
 	 */
 	@Override /* RestCallHandler */
 	public void service(HttpServletRequest r1, HttpServletResponse r2) throws ServletException, IOException {

 		logger.log(FINE, "HTTP: {0} {1}", r1.getMethod(), r1.getRequestURI());
 		long startTime = System.currentTimeMillis();

 		try {
 			context.checkForInitException();

 			String pathInfo = RestUtils.getPathInfoUndecoded(r1);  // Can't use r1.getPathInfo() because we don't want '%2F' resolved.

 			// If this resource has child resources, try to recursively call them.
 			if (pathInfo != null && context.hasChildResources() && (! pathInfo.equals("/"))) {
 				int i = pathInfo.indexOf('/', 1);
 				String pathInfoPart = i == -1 ? pathInfo.substring(1) : pathInfo.substring(1, i);
 				RestContext childResource = context.getChildResource(pathInfoPart);
 				if (childResource != null) {
 					final String pathInfoRemainder = (i == -1 ? null : pathInfo.substring(i));
 					final String servletPath = r1.getServletPath() + "/" + pathInfoPart;
 					final HttpServletRequest childRequest = new HttpServletRequestWrapper(r1) {
 						@Override /* ServletRequest */
 						public String getPathInfo() {
 							return urlDecode(pathInfoRemainder);
 						}
 						@Override /* ServletRequest */
 						public String getServletPath() {
 							return servletPath;
 						}
 					};
 					childResource.getCallHandler().service(childRequest, r2);
 					return;
 				}
 			}

 			context.startCall(r1, r2);

 			RestRequest req = createRequest(r1);
 			RestResponse res = createResponse(req, r2);
 			String method = req.getMethod();
 			String methodUC = method.toUpperCase(Locale.ENGLISH);

 			StreamResource r = null;
 			if (pathInfo != null) {
 				String p = pathInfo.substring(1);
 				if (context.isStaticFile(p))
 					r = context.resolveStaticFile(p);
 				else if (p.equals("favicon.ico"))
 					res.setOutput(null);
 			}

 			if (r != null) {
 				res.setStatus(SC_OK);
 				res.setOutput(r);
 			} else {
 				// If the specified method has been defined in a subclass, invoke it.
 				int rc = SC_METHOD_NOT_ALLOWED;
 				if (restCallRouters.containsKey(methodUC)) {
 					rc = restCallRouters.get(methodUC).invoke(pathInfo, req, res);
 				} else if (restCallRouters.containsKey("*")) {
 					rc = restCallRouters.get("*").invoke(pathInfo, req, res);
 				}

 				// If not invoked above, see if it's an OPTIONs request
 				if (rc != SC_OK)
 					handleNotFound(rc, req, res);
 			}

 			if (res.hasOutput()) {
 				Object output = res.getOutput();

 				// Do any class-level transforming.
 				for (RestConverter converter : context.getConverters())
 					output = converter.convert(req, output);

 				res.setOutput(output);

 				// Now serialize the output if there was any.
 				// Some subclasses may write to the OutputStream or Writer directly.
 				handleResponse(req, res, output);
 			}

 			// Make sure our writer in RestResponse gets written.
 			res.flushBuffer();
 			req.close();

 			r1.setAttribute("ExecTime", System.currentTimeMillis() - startTime);

 		} catch (RestException e) {
 			r1.setAttribute("Exception", e);
 			r1.setAttribute("ExecTime", System.currentTimeMillis() - startTime);
 			handleError(r1, r2, e);
 		} catch (Throwable e) {
 			RestException e2 = new RestException(SC_INTERNAL_SERVER_ERROR, e);
 			r1.setAttribute("Exception", e);
 			r1.setAttribute("ExecTime", System.currentTimeMillis() - startTime);
 			handleError(r1, r2, e2);
 		}

 		context.finishCall(r1, r2);

 		logger.log(FINE, "HTTP: [{0} {1}] finished in {2}ms", r1.getMethod(), r1.getRequestURI(), System.currentTimeMillis()-startTime);
 	}

 	/**
 	 * The main method for serializing POJOs passed in through the {@link RestResponse#setOutput(Object)} method or
 	 * returned by the Java method.
 	 *
 	 * <p>
 	 * Subclasses may override this method if they wish to modify the way the output is rendered or support other output
 	 * formats.
 	 *
 	 * <p>
 	 * The default implementation simply iterates through the response handlers on this resource
 	 * looking for the first one whose {@link ResponseHandler#handle(RestRequest, RestResponse, Object)} method returns
 	 * <jk>true</jk>.
 	 *
 	 * @param req The HTTP request.
 	 * @param res The HTTP response.
 	 * @param output The output to serialize in the response.
 	 * @throws IOException
 	 * @throws RestException
 	 */
 	@Override /* RestCallHandler */
 	public void handleResponse(RestRequest req, RestResponse res, Object output) throws IOException, RestException {
 		// Loop until we find the correct handler for the POJO.
 		for (ResponseHandler h : context.getResponseHandlers())
 			if (h.handle(req, res, output))
 				return;
 		throw new RestException(SC_NOT_IMPLEMENTED, "No response handlers found to process output of type '"+(output == null ? null : output.getClass().getName())+"'");
 	}

 	/**
 	 * Handle the case where a matching method was not found.
 	 *
 	 * <p>
 	 * Subclasses can override this method to provide a 2nd-chance for specifying a response.
 	 * The default implementation will simply throw an exception with an appropriate message.
 	 *
 	 * @param rc The HTTP response code.
 	 * @param req The HTTP request.
 	 * @param res The HTTP response.
 	 * @throws Exception
 	 */
 	@Override /* RestCallHandler */
 	public void handleNotFound(int rc, RestRequest req, RestResponse res) throws Exception {
 		String pathInfo = req.getPathInfo();
 		String methodUC = req.getMethod();
 		String onPath = pathInfo == null ? " on no pathInfo"  : String.format(" on path '%s'", pathInfo);
 		if (rc == SC_NOT_FOUND)
 			throw new RestException(rc, "Method ''{0}'' not found on resource with matching pattern{1}.", methodUC, onPath);
 		else if (rc == SC_PRECONDITION_FAILED)
 			throw new RestException(rc, "Method ''{0}'' not found on resource{1} with matching matcher.", methodUC, onPath);
 		else if (rc == SC_METHOD_NOT_ALLOWED)
 			throw new RestException(rc, "Method ''{0}'' not found on resource.", methodUC);
 		else
 			throw new ServletException("Invalid method response: " + rc);
 	}

 	/**
 	 * Method for handling response errors.
 	 *
 	 * <p>
 	 * The default implementation logs the error and calls
 	 * {@link #renderError(HttpServletRequest,HttpServletResponse,RestException)}.
 	 *
 	 * <p>
 	 * Subclasses can override this method to provide their own custom error response handling.
 	 *
 	 * @param req The servlet request.
 	 * @param res The servlet response.
 	 * @param e The exception that occurred.
 	 * @throws IOException Can be thrown if a problem occurred trying to write to the output stream.
 	 */
 	@Override /* RestCallHandler */
 	public synchronized void handleError(HttpServletRequest req, HttpServletResponse res, RestException e) throws IOException {
 		e.setOccurrence(context == null ? 0 : context.getStackTraceOccurrence(e));
 		logger.onError(req, res, e);
 		renderError(req, res, e);
 	}

 	/**
 	 * Method for rendering response errors.
 	 *
 	 * <p>
 	 * The default implementation renders a plain text English message, optionally with a stack trace if
 	 * {@link RestResource#renderResponseStackTraces() @RestResource.renderResponseStackTraces()} is enabled.
 	 *
 	 * <p>
 	 * Subclasses can override this method to provide their own custom error response handling.
 	 *
 	 * @param req The servlet request.
 	 * @param res The servlet response.
 	 * @param e The exception that occurred.
 	 * @throws IOException Can be thrown if a problem occurred trying to write to the output stream.
 	 */
 	@Override /* RestCallHandler */
 	public void renderError(HttpServletRequest req, HttpServletResponse res, RestException e) throws IOException {

 		int status = e.getStatus();
 		res.setStatus(status);
 		res.setContentType("text/plain");
 		res.setHeader("Content-Encoding", "identity");

 		Throwable t = e.getRootCause();
 		if (t != null) {
 			res.setHeader("Exception-Name", t.getClass().getName());
 			res.setHeader("Exception-Message", t.getMessage());
 		}

 		PrintWriter w = null;
 		try {
 			w = res.getWriter();
 		} catch (IllegalStateException e2) {
 			w = new PrintWriter(new OutputStreamWriter(res.getOutputStream(), UTF8));
 		}

 		try (PrintWriter w2 = w) {
 			String httpMessage = RestUtils.getHttpResponseText(status);
 			if (httpMessage != null)
 				w2.append("HTTP ").append(String.valueOf(status)).append(": ").append(httpMessage).append("\n\n");
 			if (context != null && context.isRenderResponseStackTraces())
 				e.printStackTrace(w2);
 			else
 				w2.append(e.getFullStackMessage(true));
 		}
 	}

 	/**
 	 * Returns the session objects for the specified request.
 	 *
 	 * <p>
 	 * The default implementation simply returns a single map containing <code>{'req':req}</code>.
 	 *
 	 * @param req The REST request.
 	 * @return The session objects for that request.
 	 */
 	@Override /* RestCallHandler */
 	public Map<String,Object> getSessionObjects(RestRequest req) {
 		Map<String,Object> m = new HashMap<>();
 		m.put(RequestVar.SESSION_req, req);
 		return m;
 	}
 }
	// ***************************************************************************************************************************
	// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file *
	// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file *
	// * to you 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 org.apache.juneau.rest;

	import static java.util.logging.Level.*;
	import static javax.servlet.http.HttpServletResponse.*;
	import static org.apache.juneau.internal.IOUtils.*;
	import static org.apache.juneau.internal.StringUtils.*;

	import java.io.*;
	import java.util.*;

	import javax.servlet.*;
	import javax.servlet.http.*;

	import org.apache.juneau.rest.annotation.*;
	import org.apache.juneau.rest.vars.*;

	/**
	* Default implementation of {@link RestCallHandler}.
	*
	* <p>
	* Subclasses can override these methods to tailor how HTTP REST calls are handled.
	* <br>Subclasses MUST implement a public constructor that takes in a {@link RestContext} object.
	*
	* <h5 class='section'>See Also:</h5>
	* <ul>
	* <li class='jf'>{@link RestContext#REST_callHandler}
	* </ul>
	*/
	public class BasicRestCallHandler implements RestCallHandler {

	private final RestContext context;
	private final RestLogger logger;
	private final Map<String,RestCallRouter> restCallRouters;

	/**
	* Constructor.
	*
	* @param context The resource context.
	*/
	public BasicRestCallHandler(RestContext context) {
	this.context = context;
	this.logger = context.getLogger();
	this.restCallRouters = context.getCallRouters();
	}

	/**
	* Creates a {@link RestRequest} object based on the specified incoming {@link HttpServletRequest} object.
	*
	* <p>
	* Subclasses may choose to override this method to provide a specialized request object.
	*
	* @param req The request object from the {@link #service(HttpServletRequest, HttpServletResponse)} method.
	* @return The wrapped request object.
	* @throws ServletException If any errors occur trying to interpret the request.
	*/
	@Override /* RestCallHandler */
	public RestRequest createRequest(HttpServletRequest req) throws ServletException {
	return new RestRequest(context, req);
	}

	/**
	* Creates a {@link RestResponse} object based on the specified incoming {@link HttpServletResponse} object
	* and the request returned by {@link #createRequest(HttpServletRequest)}.
	*
	* <p>
	* Subclasses may choose to override this method to provide a specialized response object.
	*
	* @param req The request object returned by {@link #createRequest(HttpServletRequest)}.
	* @param res The response object from the {@link #service(HttpServletRequest, HttpServletResponse)} method.
	* @return The wrapped response object.
	* @throws ServletException If any errors occur trying to interpret the request or response.
	*/
	@Override /* RestCallHandler */
	public RestResponse createResponse(RestRequest req, HttpServletResponse res) throws ServletException {
	return new RestResponse(context, req, res);
	}

	/**
	* The main service method.
	*
	* <p>
	* Subclasses can optionally override this method if they want to tailor the behavior of requests.
	*
	* @param r1 The incoming HTTP servlet request object.
	* @param r2 The incoming HTTP servlet response object.
	* @throws ServletException
	* @throws IOException
	*/
	@Override /* RestCallHandler */
	public void service(HttpServletRequest r1, HttpServletResponse r2) throws ServletException, IOException {

	logger.log(FINE, "HTTP: {0} {1}", r1.getMethod(), r1.getRequestURI());
	long startTime = System.currentTimeMillis();

	try {
	context.checkForInitException();

	String pathInfo = RestUtils.getPathInfoUndecoded(r1); // Can't use r1.getPathInfo() because we don't want '%2F' resolved.

	// If this resource has child resources, try to recursively call them.
	if (pathInfo != null && context.hasChildResources() && (! pathInfo.equals("/"))) {
	int i = pathInfo.indexOf('/', 1);
	String pathInfoPart = i == -1 ? pathInfo.substring(1) : pathInfo.substring(1, i);
	RestContext childResource = context.getChildResource(pathInfoPart);
	if (childResource != null) {
	final String pathInfoRemainder = (i == -1 ? null : pathInfo.substring(i));
	final String servletPath = r1.getServletPath() + "/" + pathInfoPart;
	final HttpServletRequest childRequest = new HttpServletRequestWrapper(r1) {
	@Override /* ServletRequest */
	public String getPathInfo() {
	return urlDecode(pathInfoRemainder);
	}
	@Override /* ServletRequest */
	public String getServletPath() {
	return servletPath;
	}
	};
	childResource.getCallHandler().service(childRequest, r2);
	return;
	}
	}

	context.startCall(r1, r2);

	RestRequest req = createRequest(r1);
	RestResponse res = createResponse(req, r2);
	String method = req.getMethod();
	String methodUC = method.toUpperCase(Locale.ENGLISH);

	StreamResource r = null;
	if (pathInfo != null) {
	String p = pathInfo.substring(1);
	if (context.isStaticFile(p))
	r = context.resolveStaticFile(p);
	else if (p.equals("favicon.ico"))
	res.setOutput(null);
	}

	if (r != null) {
	res.setStatus(SC_OK);
	res.setOutput(r);
	} else {
	// If the specified method has been defined in a subclass, invoke it.
	int rc = SC_METHOD_NOT_ALLOWED;
	if (restCallRouters.containsKey(methodUC)) {
	rc = restCallRouters.get(methodUC).invoke(pathInfo, req, res);
	} else if (restCallRouters.containsKey("*")) {
	rc = restCallRouters.get("*").invoke(pathInfo, req, res);
	}

	// If not invoked above, see if it's an OPTIONs request
	if (rc != SC_OK)
	handleNotFound(rc, req, res);
	}

	if (res.hasOutput()) {
	Object output = res.getOutput();

	// Do any class-level transforming.
	for (RestConverter converter : context.getConverters())
	output = converter.convert(req, output);

	res.setOutput(output);

	// Now serialize the output if there was any.
	// Some subclasses may write to the OutputStream or Writer directly.
	handleResponse(req, res, output);
	}

	// Make sure our writer in RestResponse gets written.
	res.flushBuffer();
	req.close();

	r1.setAttribute("ExecTime", System.currentTimeMillis() - startTime);

	} catch (RestException e) {
	r1.setAttribute("Exception", e);
	r1.setAttribute("ExecTime", System.currentTimeMillis() - startTime);
	handleError(r1, r2, e);
	} catch (Throwable e) {
	RestException e2 = new RestException(SC_INTERNAL_SERVER_ERROR, e);
	r1.setAttribute("Exception", e);
	r1.setAttribute("ExecTime", System.currentTimeMillis() - startTime);
	handleError(r1, r2, e2);
	}

	context.finishCall(r1, r2);

	logger.log(FINE, "HTTP: [{0} {1}] finished in {2}ms", r1.getMethod(), r1.getRequestURI(), System.currentTimeMillis()-startTime);
	}

	/**
	* The main method for serializing POJOs passed in through the {@link RestResponse#setOutput(Object)} method or
	* returned by the Java method.
	*
	* <p>
	* Subclasses may override this method if they wish to modify the way the output is rendered or support other output
	* formats.
	*
	* <p>
	* The default implementation simply iterates through the response handlers on this resource
	* looking for the first one whose {@link ResponseHandler#handle(RestRequest, RestResponse, Object)} method returns
	* <jk>true</jk>.
	*
	* @param req The HTTP request.
	* @param res The HTTP response.
	* @param output The output to serialize in the response.
	* @throws IOException
	* @throws RestException
	*/
	@Override /* RestCallHandler */
	public void handleResponse(RestRequest req, RestResponse res, Object output) throws IOException, RestException {
	// Loop until we find the correct handler for the POJO.
	for (ResponseHandler h : context.getResponseHandlers())
	if (h.handle(req, res, output))
	return;
	throw new RestException(SC_NOT_IMPLEMENTED, "No response handlers found to process output of type '"+(output == null ? null : output.getClass().getName())+"'");
	}

	/**
	* Handle the case where a matching method was not found.
	*
	* <p>
	* Subclasses can override this method to provide a 2nd-chance for specifying a response.
	* The default implementation will simply throw an exception with an appropriate message.
	*
	* @param rc The HTTP response code.
	* @param req The HTTP request.
	* @param res The HTTP response.
	* @throws Exception
	*/
	@Override /* RestCallHandler */
	public void handleNotFound(int rc, RestRequest req, RestResponse res) throws Exception {
	String pathInfo = req.getPathInfo();
	String methodUC = req.getMethod();
	String onPath = pathInfo == null ? " on no pathInfo" : String.format(" on path '%s'", pathInfo);
	if (rc == SC_NOT_FOUND)
	throw new RestException(rc, "Method ''{0}'' not found on resource with matching pattern{1}.", methodUC, onPath);
	else if (rc == SC_PRECONDITION_FAILED)
	throw new RestException(rc, "Method ''{0}'' not found on resource{1} with matching matcher.", methodUC, onPath);
	else if (rc == SC_METHOD_NOT_ALLOWED)
	throw new RestException(rc, "Method ''{0}'' not found on resource.", methodUC);
	else
	throw new ServletException("Invalid method response: " + rc);
	}

	/**
	* Method for handling response errors.
	*
	* <p>
	* The default implementation logs the error and calls
	* {@link #renderError(HttpServletRequest,HttpServletResponse,RestException)}.
	*
	* <p>
	* Subclasses can override this method to provide their own custom error response handling.
	*
	* @param req The servlet request.
	* @param res The servlet response.
	* @param e The exception that occurred.
	* @throws IOException Can be thrown if a problem occurred trying to write to the output stream.
	*/
	@Override /* RestCallHandler */
	public synchronized void handleError(HttpServletRequest req, HttpServletResponse res, RestException e) throws IOException {
	e.setOccurrence(context == null ? 0 : context.getStackTraceOccurrence(e));
	logger.onError(req, res, e);
	renderError(req, res, e);
	}

	/**
	* Method for rendering response errors.
	*
	* <p>
	* The default implementation renders a plain text English message, optionally with a stack trace if
	* {@link RestResource#renderResponseStackTraces() @RestResource.renderResponseStackTraces()} is enabled.
	*
	* <p>
	* Subclasses can override this method to provide their own custom error response handling.
	*
	* @param req The servlet request.
	* @param res The servlet response.
	* @param e The exception that occurred.
	* @throws IOException Can be thrown if a problem occurred trying to write to the output stream.
	*/
	@Override /* RestCallHandler */
	public void renderError(HttpServletRequest req, HttpServletResponse res, RestException e) throws IOException {

	int status = e.getStatus();
	res.setStatus(status);
	res.setContentType("text/plain");
	res.setHeader("Content-Encoding", "identity");

	Throwable t = e.getRootCause();
	if (t != null) {
	res.setHeader("Exception-Name", t.getClass().getName());
	res.setHeader("Exception-Message", t.getMessage());
	}

	PrintWriter w = null;
	try {
	w = res.getWriter();
	} catch (IllegalStateException e2) {
	w = new PrintWriter(new OutputStreamWriter(res.getOutputStream(), UTF8));
	}

	try (PrintWriter w2 = w) {
	String httpMessage = RestUtils.getHttpResponseText(status);
	if (httpMessage != null)
	w2.append("HTTP ").append(String.valueOf(status)).append(": ").append(httpMessage).append("\n\n");
	if (context != null && context.isRenderResponseStackTraces())
	e.printStackTrace(w2);
	else
	w2.append(e.getFullStackMessage(true));
	}
	}

	/**
	* Returns the session objects for the specified request.
	*
	* <p>
	* The default implementation simply returns a single map containing <code>{'req':req}</code>.
	*
	* @param req The REST request.
	* @return The session objects for that request.
	*/
	@Override /* RestCallHandler */
	public Map<String,Object> getSessionObjects(RestRequest req) {
	Map<String,Object> m = new HashMap<>();
	m.put(RequestVar.SESSION_req, req);
	return m;
	}
	}