blob: 2aea97d634d29e519cd4ef43eeae9f57c0b21450 [file] [log] [blame]
// Copyright 2012 Google Inc. All Rights Reserved.
//
// 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.gitiles;
import static com.google.common.base.MoreObjects.firstNonNull;
import static com.google.gitiles.FormatType.DEFAULT;
import static com.google.gitiles.FormatType.HTML;
import static com.google.gitiles.FormatType.JSON;
import static com.google.gitiles.FormatType.TEXT;
import static java.nio.charset.StandardCharsets.UTF_8;
import static javax.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
import static javax.servlet.http.HttpServletResponse.SC_OK;
import static org.eclipse.jgit.util.HttpSupport.ENCODING_GZIP;
import com.google.common.base.Joiner;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.google.common.net.HttpHeaders;
import com.google.gitiles.GitilesRequestFailureException.FailureReason;
import com.google.gson.FieldNamingPolicy;
import com.google.gson.GsonBuilder;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.lang.reflect.Type;
import java.time.Instant;
import java.util.Map;
import java.util.Optional;
import java.util.regex.Pattern;
import java.util.zip.GZIPOutputStream;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/** Base servlet class for Gitiles servlets that serve Soy templates. */
public abstract class BaseServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private static final String DATA_ATTRIBUTE = BaseServlet.class.getName() + "/Data";
private static final String STREAMING_ATTRIBUTE = BaseServlet.class.getName() + "/Streaming";
static void setNotCacheable(HttpServletResponse res) {
res.setHeader(HttpHeaders.CACHE_CONTROL, "no-cache, no-store, max-age=0, must-revalidate");
res.setHeader(HttpHeaders.PRAGMA, "no-cache");
res.setHeader(HttpHeaders.EXPIRES, "Mon, 01 Jan 1990 00:00:00 GMT");
res.setDateHeader(HttpHeaders.DATE, Instant.now().toEpochMilli());
}
public static BaseServlet notFoundServlet() {
return new BaseServlet(null, null) {
private static final long serialVersionUID = 1L;
@Override
public void service(HttpServletRequest req, HttpServletResponse res) {
res.setStatus(SC_NOT_FOUND);
}
};
}
public static Map<String, String> menuEntry(String text, String url) {
if (url != null) {
return ImmutableMap.of("text", text, "url", url);
}
return ImmutableMap.of("text", text);
}
public static boolean isStreamingResponse(HttpServletRequest req) {
return firstNonNull((Boolean) req.getAttribute(STREAMING_ATTRIBUTE), false);
}
protected static ArchiveFormat getArchiveFormat(GitilesAccess access) throws IOException {
return ArchiveFormat.getDefault(access.getConfig());
}
/**
* Put a value into a request's Soy data map.
*
* @param req in-progress request.
* @param key key.
* @param value Soy data value.
*/
public static void putSoyData(HttpServletRequest req, String key, Object value) {
getData(req).put(key, value);
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse res)
throws IOException, ServletException {
Optional<FormatType> format = getFormat(req);
if (!format.isPresent()) {
res.sendError(SC_BAD_REQUEST);
return;
}
switch (format.get()) {
case HTML:
doGetHtml(req, res);
break;
case TEXT:
doGetText(req, res);
break;
case JSON:
doGetJson(req, res);
break;
case DEFAULT:
default:
throw new GitilesRequestFailureException(FailureReason.UNSUPPORTED_RESPONSE_FORMAT);
}
}
protected Optional<FormatType> getFormat(HttpServletRequest req) {
Optional<FormatType> format = FormatType.getFormatType(req);
if (format.isPresent() && format.get() == DEFAULT) {
return Optional.of(getDefaultFormat(req));
}
return format;
}
/**
* Get default format
*
* @param req in-progress request.
* @return the default {@link FormatType} used when {@code ?format=} is not specified.
*/
protected FormatType getDefaultFormat(HttpServletRequest req) {
return HTML;
}
/**
* Handle a GET request when the requested format type was HTML.
*
* @param req in-progress request.
* @param res in-progress response.
* @throws IOException if there was an error rendering the result.
*/
protected void doGetHtml(HttpServletRequest req, HttpServletResponse res) throws IOException {
throw new GitilesRequestFailureException(FailureReason.UNSUPPORTED_RESPONSE_FORMAT);
}
/**
* Handle a GET request when the requested format type was plain text.
*
* @param req in-progress request.
* @param res in-progress response.
* @throws IOException if there was an error rendering the result.
*/
protected void doGetText(HttpServletRequest req, HttpServletResponse res) throws IOException {
throw new GitilesRequestFailureException(FailureReason.UNSUPPORTED_RESPONSE_FORMAT);
}
/**
* Handle a GET request when the requested format type was JSON.
*
* @param req in-progress request.
* @param res in-progress response.
* @throws IOException if there was an error rendering the result.
*/
protected void doGetJson(HttpServletRequest req, HttpServletResponse res) throws IOException {
throw new GitilesRequestFailureException(FailureReason.UNSUPPORTED_RESPONSE_FORMAT);
}
protected static Map<String, Object> getData(HttpServletRequest req) {
@SuppressWarnings("unchecked")
Map<String, Object> data = (Map<String, Object>) req.getAttribute(DATA_ATTRIBUTE);
if (data == null) {
data = Maps.newHashMap();
req.setAttribute(DATA_ATTRIBUTE, data);
}
return data;
}
protected final Renderer renderer;
private final GitilesAccess.Factory accessFactory;
protected BaseServlet(Renderer renderer, GitilesAccess.Factory accessFactory) {
this.renderer = renderer;
this.accessFactory = accessFactory;
}
/**
* Render data to HTML using Soy.
*
* @param req in-progress request.
* @param res in-progress response.
* @param templateName Soy template name; must be in one of the template files defined in {@link
* Renderer}.
* @param soyData data for Soy.
* @throws IOException an error occurred during rendering.
*/
protected void renderHtml(
HttpServletRequest req, HttpServletResponse res, String templateName, Map<String, ?> soyData)
throws IOException {
renderer.renderHtml(req, res, templateName, startHtmlResponse(req, res, soyData));
}
/**
* Start a streaming HTML response with header and footer rendered by Soy.
*
* <p>A streaming template includes the special template {@code gitiles.streamingPlaceholder} at
* the point where data is to be streamed. The template before and after this placeholder is
* rendered using the provided data map.
*
* @param req in-progress request.
* @param res in-progress response.
* @param templateName Soy template name; must be in one of the template files defined in {@link
* Renderer}.
* @param soyData data for Soy.
* @return output stream to render to. The portion of the template before the placeholder is
* already written and flushed; the portion after is written only on calling {@code close()}.
* @throws IOException an error occurred during rendering the header.
*/
protected OutputStream startRenderStreamingHtml(
HttpServletRequest req, HttpServletResponse res, String templateName, Map<String, ?> soyData)
throws IOException {
req.setAttribute(STREAMING_ATTRIBUTE, true);
return renderer.renderHtmlStreaming(
req, res, false, templateName, startHtmlResponse(req, res, soyData));
}
/**
* Start a compressed, streaming HTML response with header and footer rendered by Soy.
*
* <p>A streaming template includes the special template {@code gitiles.streamingPlaceholder} at
* the point where data is to be streamed. The template before and after this placeholder is
* rendered using the provided data map.
*
* <p>The response will be gzip compressed (if the user agent supports it) to reduce bandwidth.
* This may delay rendering in the browser.
*
* @param req in-progress request.
* @param res in-progress response.
* @param templateName Soy template name; must be in one of the template files defined in {@link
* Renderer}.
* @param soyData data for Soy.
* @return output stream to render to. The portion of the template before the placeholder is
* already written and flushed; the portion after is written only on calling {@code close()}.
* @throws IOException an error occurred during rendering the header.
*/
protected OutputStream startRenderCompressedStreamingHtml(
HttpServletRequest req, HttpServletResponse res, String templateName, Map<String, ?> soyData)
throws IOException {
req.setAttribute(STREAMING_ATTRIBUTE, true);
boolean gzip = false;
if (acceptsGzipEncoding(req)) {
res.addHeader(HttpHeaders.VARY, HttpHeaders.ACCEPT_ENCODING);
res.setHeader(HttpHeaders.CONTENT_ENCODING, "gzip");
gzip = true;
}
return renderer.renderHtmlStreaming(
req, res, gzip, templateName, startHtmlResponse(req, res, soyData));
}
private Map<String, ?> startHtmlResponse(
HttpServletRequest req, HttpServletResponse res, Map<String, ?> soyData) throws IOException {
res.setContentType(FormatType.HTML.getMimeType());
res.setCharacterEncoding(UTF_8.name());
setCacheHeaders(req, res);
Map<String, Object> allData = getData(req);
// for backwards compatibility, first try to access the old customHeader config var,
// then read the new customVariant variable.
GitilesConfig.putVariant(getAccess(req).getConfig(), "customHeader", "customVariant", allData);
GitilesConfig.putVariant(getAccess(req).getConfig(), "customVariant", "customVariant", allData);
allData.putAll(soyData);
GitilesView view = ViewFilter.getView(req);
if (!allData.containsKey("repositoryName") && view.getRepositoryName() != null) {
allData.put("repositoryName", view.getRepositoryName());
}
if (!allData.containsKey("breadcrumbs") && view.getRepositoryName() != null) {
allData.put("breadcrumbs", view.getBreadcrumbs());
}
res.setStatus(HttpServletResponse.SC_OK);
return allData;
}
/**
* Render data to JSON using GSON.
*
* @param req in-progress request.
* @param res in-progress response.
* @param src source, @see com.google.gson.Gson#toJson(Object, Type, Appendable)
* @param typeOfSrc type of source, @see com.google.gson.Gson#toJson(Object, Type, Appendable)
*/
protected void renderJson(
HttpServletRequest req, HttpServletResponse res, Object src, Type typeOfSrc)
throws IOException {
setApiHeaders(req, res, JSON);
res.setStatus(SC_OK);
try (Writer writer = newWriter(req, res)) {
newGsonBuilder(req).create().toJson(src, typeOfSrc, writer);
writer.write('\n');
}
}
@SuppressWarnings("unused") // Used in subclasses.
protected GsonBuilder newGsonBuilder(HttpServletRequest req) throws IOException {
return new GsonBuilder()
.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
.setPrettyPrinting()
.generateNonExecutableJson();
}
/**
* Start to render text.
*
* @see #startRenderText(HttpServletRequest, HttpServletResponse)
* @param req in-progress request.
* @param res in-progress response.
* @param contentType contentType to set.
* @return the response's writer.
*/
protected Writer startRenderText(
HttpServletRequest req, HttpServletResponse res, String contentType) throws IOException {
setApiHeaders(req, res, contentType);
return newWriter(req, res);
}
/**
* Prepare the response to render plain text.
*
* <p>Unlike {@link #renderHtml(HttpServletRequest, HttpServletResponse, String, Map)} and {@link
* #renderJson(HttpServletRequest, HttpServletResponse, Object, Type)}, which assume the data to
* render is already completely prepared, this method does not write any data, only headers, and
* returns the response's ready-to-use writer.
*
* @param req in-progress request.
* @param res in-progress response.
* @return the response's writer.
*/
protected Writer startRenderText(HttpServletRequest req, HttpServletResponse res)
throws IOException {
return startRenderText(req, res, TEXT.getMimeType());
}
/**
* Render an error as plain text.
*
* @param req in-progress request.
* @param res in-progress response.
* @param statusCode HTTP status code.
* @param message full message text.
* @throws IOException if an IO error occurred.
*/
protected void renderTextError(
HttpServletRequest req, HttpServletResponse res, int statusCode, String message)
throws IOException {
res.setStatus(statusCode);
setApiHeaders(req, res, TEXT);
setCacheHeaders(req, res);
try (Writer out = newWriter(req, res)) {
out.write(message);
}
}
protected GitilesAccess getAccess(HttpServletRequest req) {
return GitilesAccess.getAccess(req, accessFactory);
}
protected void setCacheHeaders(HttpServletRequest req, HttpServletResponse res) {
if (Strings.nullToEmpty(req.getHeader(HttpHeaders.PRAGMA)).equalsIgnoreCase("no-cache")
|| Strings.nullToEmpty(req.getHeader(HttpHeaders.CACHE_CONTROL))
.equalsIgnoreCase("no-cache")) {
setNotCacheable(res);
return;
}
GitilesView view = ViewFilter.getView(req);
Revision rev = view.getRevision();
if (rev.nameIsId()) {
res.setHeader(
HttpHeaders.CACHE_CONTROL, "private, max-age=7200, stale-while-revalidate=604800");
return;
}
setNotCacheable(res);
}
protected void setApiHeaders(HttpServletRequest req, HttpServletResponse res, String contentType)
throws IOException {
if (!Strings.isNullOrEmpty(contentType)) {
res.setContentType(contentType);
}
res.setCharacterEncoding(UTF_8.name());
res.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment");
GitilesAccess access = getAccess(req);
String[] allowOrigin = access.getConfig().getStringList("gitiles", null, "allowOriginRegex");
if (allowOrigin.length > 0) {
String origin = req.getHeader(HttpHeaders.ORIGIN);
Pattern allowOriginPattern = Pattern.compile(Joiner.on("|").join(allowOrigin));
if (!Strings.isNullOrEmpty(origin) && allowOriginPattern.matcher(origin).matches()) {
res.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, origin);
res.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, "X-Requested-With");
res.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");
res.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, "GET");
}
} else {
res.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
}
setCacheHeaders(req, res);
}
protected void setApiHeaders(HttpServletRequest req, HttpServletResponse res, FormatType type)
throws IOException {
setApiHeaders(req, res, type.getMimeType());
}
protected void setDownloadHeaders(
HttpServletRequest req, HttpServletResponse res, String filename, String contentType) {
res.setContentType(contentType);
res.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + filename);
setCacheHeaders(req, res);
}
protected static Writer newWriter(OutputStream os, HttpServletResponse res) throws IOException {
// StreamEncoder#write(int) is wasteful with its allocations, and we don't have much control
// over whether library code calls that variant as opposed to the saner write(char[], int, int).
// Protect against this by buffering.
return new BufferedWriter(new OutputStreamWriter(os, res.getCharacterEncoding()));
}
private Writer newWriter(HttpServletRequest req, HttpServletResponse res) throws IOException {
OutputStream out;
if (acceptsGzipEncoding(req)) {
res.addHeader(HttpHeaders.VARY, HttpHeaders.ACCEPT_ENCODING);
res.setHeader(HttpHeaders.CONTENT_ENCODING, "gzip");
out = new GZIPOutputStream(res.getOutputStream());
} else {
out = res.getOutputStream();
}
return newWriter(out, res);
}
protected static boolean acceptsGzipEncoding(HttpServletRequest req) {
String accepts = req.getHeader(HttpHeaders.ACCEPT_ENCODING);
if (accepts == null) {
return false;
}
for (int b = 0; b < accepts.length(); ) {
int comma = accepts.indexOf(',', b);
int e = 0 <= comma ? comma : accepts.length();
String term = accepts.substring(b, e).trim();
if (term.equals(ENCODING_GZIP)) {
return true;
}
b = e + 1;
}
return false;
}
protected static byte[] gzip(byte[] raw) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
try (GZIPOutputStream gz = new GZIPOutputStream(out)) {
gz.write(raw);
}
return out.toByteArray();
}
}