Java tutorial
// 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.enterprise.adaptor.sharepoint; import com.google.common.annotations.VisibleForTesting; import com.google.common.collect.Multimap; import com.google.common.io.CountingOutputStream; import com.google.enterprise.adaptor.DocId; import com.google.enterprise.adaptor.DocIdEncoder; import com.google.enterprise.adaptor.DocIdPusher; import com.microsoft.schemas.sharepoint.soap.ObjectType; import java.io.Closeable; import java.io.IOException; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.Writer; import java.net.URI; import java.net.URISyntaxException; import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Collection; import java.util.Locale; import java.util.Map; import java.util.concurrent.Executor; import java.util.logging.Level; import java.util.logging.Logger; class HtmlResponseWriter implements Closeable { /** * The number of bytes that may be buffered within the streams. It should * error on the side of being too large. */ private static final long POSSIBLY_BUFFERED_BYTES = 1024; private static final Logger log = Logger.getLogger(HtmlResponseWriter.class.getName()); private enum State { /** Initial state after construction. */ INITIAL, /** * {@link #start} was just called, so the HTML header is in place, but no * other content. */ STARTED, /** {@link #startSection} has been called, so we are within a section. */ IN_SECTION, /** {@link #finish} has been called, so the HTML footer has been written. */ FINISHED, /** The writer has been closed. */ CLOSED, } private final Writer writer; private final DocIdEncoder docIdEncoder; private final Locale locale; private final long thresholdBytes; private final CountingOutputStream countingOutputStream; private final DocIdPusher pusher; private final Executor executor; private DocId docId; private URI docUri; private State state = State.INITIAL; private final Collection<DocId> overflowDocIds = new ArrayList<DocId>(1024); public HtmlResponseWriter(OutputStream os, Charset charset, DocIdEncoder docIdEncoder, Locale locale, long thresholdBytes, DocIdPusher pusher, Executor executor) { if (os == null) { throw new NullPointerException(); } if (charset == null) { throw new NullPointerException(); } if (docIdEncoder == null) { throw new NullPointerException(); } if (locale == null) { throw new NullPointerException(); } if (pusher == null) { throw new NullPointerException(); } if (executor == null) { throw new NullPointerException(); } countingOutputStream = new CountingOutputStream(os); this.writer = new OutputStreamWriter(countingOutputStream, charset); this.docIdEncoder = docIdEncoder; this.locale = locale; this.thresholdBytes = thresholdBytes; this.pusher = pusher; this.executor = executor; } /** * Start writing HTML document. * * @param docId the DocId for the document being written out * @param type type of document referred to by {@code docId} * @param label possibly-{@code null} title or name of {@code docId} */ public void start(DocId docId, ObjectType type, String label) throws IOException { if (state != State.INITIAL) { throw new IllegalStateException("In unexpected state: " + state); } this.docId = docId; this.docUri = docIdEncoder.encodeDocId(docId); String documentLabel = computeLabel(label, docId); writer.write("<!DOCTYPE html>\n<html><head><title>"); writer.write(escapeContent(documentLabel)); writer.write("</title></head><body><h1>"); googleoffIndex(); // TODO(ejona): Localize. writer.write(computeTypeHeaderLabel(type)); googleonIndex(); writer.write(" "); writer.write(escapeContent(documentLabel)); writer.write("</h1>"); state = State.STARTED; } public void startSection(ObjectType type) throws IOException { if (state != State.STARTED && state != State.IN_SECTION) { throw new IllegalStateException("In unexpected state: " + state); } checkAndCloseSection(); writer.write("<p>"); googleoffIndex(); writer.write(escapeContent(computeTypeSectionLabel(type))); googleonIndex(); writer.write("</p><ul>"); state = State.IN_SECTION; } private void checkAndCloseSection() throws IOException { if (state == State.IN_SECTION) { writer.write("</ul>"); } } /** * @param docId docId to add as a link in the document * @param label possibly-{@code null} title or description of {@code docId} */ public void addLink(DocId doc, String label) throws IOException { if (state != State.IN_SECTION) { throw new IllegalStateException("In unexpected state: " + state); } if (doc == null) { throw new NullPointerException(); } if (countingOutputStream.getCount() + POSSIBLY_BUFFERED_BYTES > thresholdBytes) { overflowDocIds.add(doc); } writer.write("<li><a href=\""); writer.write(escapeAttributeValue(encodeDocId(doc))); writer.write("\">"); writer.write(escapeContent(computeLabel(label, doc))); writer.write("</a></li>"); } private void addComment(String comment) throws IOException { writer.write("<!--"); writer.write(escapeContent(comment)); writer.write("-->"); } private void googleoffIndex() throws IOException { addComment("googleoff: index"); } private void googleonIndex() throws IOException { addComment("googleon: index"); } public void addMetadata(Multimap<String, String> metadata) throws IOException { checkAndCloseSection(); googleoffIndex(); writer.write("<table style='border: none'>"); for (Map.Entry<String, String> me : metadata.entries()) { writer.write("<tr><td>"); writer.write(escapeContent(me.getKey())); writer.write("</td><td>"); writer.write(escapeContent(me.getValue())); writer.write("</td></tr>"); } writer.write("</table>"); googleonIndex(); state = State.STARTED; } /** * Complete HTML body and flush. */ public void finish() throws IOException { log.entering("HtmlResponseWriter", "finish"); if (state != State.STARTED && state != State.IN_SECTION) { throw new IllegalStateException("In unexpected state: " + state); } if (!overflowDocIds.isEmpty()) { executor.execute(new Runnable() { @Override public void run() { try { pusher.pushDocIds(overflowDocIds); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); } } }); } checkAndCloseSection(); writer.write("</body></html>"); writer.flush(); state = State.FINISHED; log.exiting("HtmlResponseWriter", "finish"); } /** * Close underlying writer. You will generally want to call {@link #finish} * first. */ @Override public void close() throws IOException { log.entering("HtmlResponseWriter", "close"); writer.close(); state = State.CLOSED; log.exiting("HtmlResponseWriter", "close"); } /** * Encodes a DocId into a URI formatted as a string. */ private String encodeDocId(DocId doc) { log.entering("HtmlResponseWriter", "encodeDocId", doc); URI uri = docIdEncoder.encodeDocId(doc); uri = relativize(docUri, uri); String encoded = uri.toASCIIString(); log.exiting("HtmlResponseWriter", "encodeDocId", encoded); return encoded; } /** * Produce a relative URI from {@code uri} relative to {@code base}, assuming * both URIs are hierarchial. If possible, a relative URI will be returned * that can be resolved from {@code base}, otherwise {@code uri} will be * returned. * * <p>Necessary since {@link URI#relativize} is broken when considering * http://host/path vs http://host/path/ as the base URI. See * <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6226081"> * Bug 6226081</a> for more information. In addition, this version uses * {@code ..} when possible unlike {@link URI#relativize}. */ @VisibleForTesting static URI relativize(URI base, URI uri) { if (base.getScheme() == null || !base.getScheme().equals(uri.getScheme()) || base.getAuthority() == null || !base.getAuthority().equals(uri.getAuthority())) { return uri; } if (base.equals(uri)) { return URI.create("#"); } // These paths are known to start with a / or be the empty string; since the // URIs have a scheme, we know they are absolute. String basePath = base.getPath(); String uriPath = uri.getPath(); String[] basePathParts = basePath.split("/", -1); String[] uriPathParts = uriPath.split("/", -1); int i = 0; // Remove common folders. Since we are looking at folders, we don't compare // the last elements in the array, because they were after the last '/' in // the URIs. for (; i < basePathParts.length - 1 && i < uriPathParts.length - 1; i++) { if (!basePathParts[i].equals(uriPathParts[i])) { break; } } StringBuilder pathBuilder = new StringBuilder(); for (int j = i; j < basePathParts.length - 1; j++) { pathBuilder.append("../"); } for (; i < uriPathParts.length; i++) { pathBuilder.append(uriPathParts[i]); pathBuilder.append("/"); } String path = pathBuilder.substring(0, pathBuilder.length() - 1); int colonLocation = path.indexOf(":"); int slashLocation = path.indexOf("/"); if (colonLocation != -1 && (slashLocation == -1 || colonLocation < slashLocation)) { // If there is a colon before the first slash, then it is easy to confuse // this relative URI for an absolute URI. Thus, we prepend a ./ so that // the beginning is obviously not a scheme. path = "./" + path; } try { return new URI(null, null, path, uri.getQuery(), uri.getFragment()); } catch (URISyntaxException ex) { throw new AssertionError(ex); } } private String computeLabel(String label, DocId doc) { if (label == null || "".equals(label)) { // Use the last part of the URL if an item doesn't have a title. The last // part of the URL will generally be a filename in this case. String[] parts = doc.getUniqueId().split("/", 0); label = parts[parts.length - 1]; } return label; } private String computeTypeHeaderLabel(ObjectType type) { // TODO(ejona): Localize. switch (type) { case VIRTUAL_SERVER: return "Virtual Server"; case SITE: return "Site"; case LIST: return "List"; case FOLDER: return "Folder"; case LIST_ITEM: return "List Item"; default: log.log(Level.WARNING, "Unexpected ObjectType: {0}", type); return ""; } } private String computeTypeSectionLabel(ObjectType type) { // TODO(ejona): Localize. switch (type) { case SITE: return "Sites"; case LIST: return "Lists"; case FOLDER: return "Folders"; case LIST_ITEM: return "List Items"; case LIST_ITEM_ATTACHMENTS: return "Attachments"; default: log.log(Level.WARNING, "Unexpected ObjectType: {0}", type); return ""; } } private String escapeContent(String raw) { return raw.replace("&", "&").replace("<", "<"); } private String escapeAttributeValue(String raw) { return escapeContent(raw).replace("\"", """).replace("'", "'"); } }