/*
* Copyright 2012 gitblit.com.
*
* 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.gitblit.servlet;
import java.io.IOException;
import java.text.MessageFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevTree;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.gitblit.Constants;
import com.gitblit.IStoredSettings;
import com.gitblit.Keys;
import com.gitblit.dagger.DaggerServlet;
import com.gitblit.manager.IRepositoryManager;
import com.gitblit.models.PathModel;
import com.gitblit.models.RefModel;
import com.gitblit.utils.ArrayUtils;
import com.gitblit.utils.ByteFormat;
import com.gitblit.utils.JGitUtils;
import com.gitblit.utils.MarkdownUtils;
import com.gitblit.utils.StringUtils;
import com.gitblit.wicket.MarkupProcessor;
import com.gitblit.wicket.MarkupProcessor.MarkupDocument;
import dagger.ObjectGraph;
/**
* Serves the content of a gh-pages branch.
*
* @author James Moger
*
*/
public class PagesServlet extends DaggerServlet {
private static final long serialVersionUID = 1L;
private transient Logger logger = LoggerFactory.getLogger(PagesServlet.class);
private IStoredSettings settings;
private IRepositoryManager repositoryManager;
@Override
protected void inject(ObjectGraph dagger) {
this.settings = dagger.get(IStoredSettings.class);
this.repositoryManager = dagger.get(IRepositoryManager.class);
}
/**
* Returns an url to this servlet for the specified parameters.
*
* @param baseURL
* @param repository
* @param path
* @return an url
*/
public static String asLink(String baseURL, String repository, String path) {
if (baseURL.length() > 0 && baseURL.charAt(baseURL.length() - 1) == '/') {
baseURL = baseURL.substring(0, baseURL.length() - 1);
}
return baseURL + Constants.PAGES + repository + "/" + (path == null ? "" : ("/" + path));
}
/**
* Retrieves the specified resource from the gh-pages branch of the
* repository.
*
* @param request
* @param response
* @throws javax.servlet.ServletException
* @throws java.io.IOException
*/
private void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String path = request.getPathInfo();
if (path.toLowerCase().endsWith(".git")) {
// forward to url with trailing /
// this is important for relative pages links
response.sendRedirect(request.getServletPath() + path + "/");
return;
}
if (path.charAt(0) == '/') {
// strip leading /
path = path.substring(1);
}
// determine repository and resource from url
String repository = "";
String resource = "";
Repository r = null;
int offset = 0;
while (r == null) {
int slash = path.indexOf('/', offset);
if (slash == -1) {
repository = path;
} else {
repository = path.substring(0, slash);
}
r = repositoryManager.getRepository(repository, false);
offset = slash + 1;
if (offset > 0) {
resource = path.substring(offset);
}
if (repository.equals(path)) {
// either only repository in url or no repository found
break;
}
}
ServletContext context = request.getSession().getServletContext();
try {
if (r == null) {
// repository not found!
String mkd = MessageFormat.format(
"# Error\nSorry, no valid **repository** specified in this url: {0}!",
repository);
error(response, mkd);
return;
}
// retrieve the content from the repository
RefModel pages = JGitUtils.getPagesBranch(r);
RevCommit commit = JGitUtils.getCommit(r, pages.getObjectId().getName());
if (commit == null) {
// branch not found!
String mkd = MessageFormat.format(
"# Error\nSorry, the repository {0} does not have a **gh-pages** branch!",
repository);
error(response, mkd);
return;
}
MarkupProcessor processor = new MarkupProcessor(settings);
String [] encodings = settings.getStrings(Keys.web.blobEncodings).toArray(new String[0]);
RevTree tree = commit.getTree();
String res = resource;
if (res.endsWith("/")) {
res = res.substring(0, res.length() - 1);
}
List<PathModel> pathEntries = JGitUtils.getFilesInPath(r, res, commit);
byte[] content = null;
if (pathEntries.isEmpty()) {
// not a path, a specific resource
try {
String contentType = context.getMimeType(res);
if (contentType == null) {
contentType = "text/plain";
}
if (contentType.startsWith("text")) {
content = JGitUtils.getStringContent(r, tree, res, encodings).getBytes(
Constants.ENCODING);
} else {
content = JGitUtils.getByteContent(r, tree, res, false);
}
response.setContentType(contentType);
} catch (Exception e) {
}
} else {
// path request
if (!request.getPathInfo().endsWith("/")) {
// redirect to trailing '/' url
response.sendRedirect(request.getServletPath() + request.getPathInfo() + "/");
return;
}
Map<String, String> names = new TreeMap<String, String>();
for (PathModel entry : pathEntries) {
names.put(entry.name.toLowerCase(), entry.name);
}
List<String> extensions = new ArrayList<String>();
extensions.add("html");
extensions.add("htm");
extensions.addAll(processor.getMarkupExtensions());
for (String ext : extensions) {
String key = "index." + ext;
if (names.containsKey(key)) {
String fileName = names.get(key);
String fullPath = fileName;
if (!res.isEmpty()) {
fullPath = res + "/" + fileName;
}
String stringContent = JGitUtils.getStringContent(r, tree, fullPath, encodings);
if (stringContent == null) {
continue;
}
content = stringContent.getBytes(Constants.ENCODING);
if (content != null) {
res = fullPath;
// assume text/html unless the servlet container
// overrides
response.setContentType("text/html; charset=" + Constants.ENCODING);
break;
}
}
}
}
// no content, document list or custom 404 page
if (ArrayUtils.isEmpty(content)) {
if (pathEntries.isEmpty()) {
// 404
String custom404 = JGitUtils.getStringContent(r, tree, "404.html", encodings);
if (!StringUtils.isEmpty(custom404)) {
content = custom404.getBytes(Constants.ENCODING);
}
// still no content
if (ArrayUtils.isEmpty(content)) {
String str = MessageFormat.format(
"# Error\nSorry, the requested resource **{0}** was not found.",
resource);
content = MarkdownUtils.transformMarkdown(str).getBytes(Constants.ENCODING);
}
try {
// output the content
logger.warn("Pages 404: " + resource);
response.setStatus(HttpServletResponse.SC_NOT_FOUND);
response.getOutputStream().write(content);
response.flushBuffer();
} catch (Throwable t) {
logger.error("Failed to write page to client", t);
}
} else {
// document list
response.setContentType("text/html");
response.getWriter().append("<style>table th, table td { min-width: 150px; text-align: left; }</style>");
response.getWriter().append("<table>");
response.getWriter().append("<thead><tr><th>path</th><th>mode</th><th>size</th></tr>");
response.getWriter().append("</thead>");
response.getWriter().append("<tbody>");
String pattern = "<tr><td><a href=\"{0}/{1}\">{1}</a></td><td>{2}</td><td>{3}</td></tr>";
final ByteFormat byteFormat = new ByteFormat();
if (!pathEntries.isEmpty()) {
if (pathEntries.get(0).path.indexOf('/') > -1) {
// we are in a subdirectory, add parent directory link
pathEntries.add(0, new PathModel("..", resource + "/..", 0, FileMode.TREE.getBits(), null, null));
}
}
String basePath = request.getServletPath() + request.getPathInfo();
if (basePath.charAt(basePath.length() - 1) == '/') {
// strip trailing slash
basePath = basePath.substring(0, basePath.length() - 1);
}
for (PathModel entry : pathEntries) {
response.getWriter().append(MessageFormat.format(pattern, basePath, entry.name,
JGitUtils.getPermissionsFromMode(entry.mode), byteFormat.format(entry.size)));
}
response.getWriter().append("</tbody>");
response.getWriter().append("</table>");
}
return;
}
// check to see if we should transform markup files
String ext = StringUtils.getFileExtension(resource);
if (processor.getMarkupExtensions().contains(ext)) {
String markup = new String(content, Constants.ENCODING);
MarkupDocument markupDoc = processor.parse(repository, commit.getName(), resource, markup);
content = markupDoc.html.getBytes("UTF-8");
response.setContentType("text/html; charset=" + Constants.ENCODING);
}
try {
// output the content
response.setHeader("Cache-Control", "public, max-age=3600, must-revalidate");
response.setDateHeader("Last-Modified", JGitUtils.getCommitDate(commit).getTime());
response.getOutputStream().write(content);
response.flushBuffer();
} catch (Throwable t) {
logger.error("Failed to write page to client", t);
}
} catch (Throwable t) {
logger.error("Failed to write page to client", t);
} finally {
r.close();
}
}
private void error(HttpServletResponse response, String mkd) throws ServletException,
IOException, ParseException {
String content = MarkdownUtils.transformMarkdown(mkd);
response.setContentType("text/html; charset=" + Constants.ENCODING);
response.getWriter().write(content);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
}