// 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();

}

}