EsiRenderer.java

/*
 * 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 org.esigate.extension.parallelesi;

import java.io.IOException;
import java.io.Writer;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.regex.Pattern;

import org.apache.http.HttpStatus;
import org.esigate.HttpErrorPage;
import org.esigate.Renderer;
import org.esigate.impl.DriverRequest;
import org.esigate.parser.future.FutureAppendable;
import org.esigate.parser.future.FutureAppendableAdapter;
import org.esigate.parser.future.FutureParser;
import org.esigate.parser.future.StringBuilderFutureAppendable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Retrieves a resource from the provider application and parses it to find ESI tags to be replaced by contents from
 * other applications.
 * 
 * For more information about ESI language specification, see <a href="http://www.w3.org/TR/esi-lang">Edge Side
 * Include</a>
 * 
 * <p>
 * This class is based on EsiRenderer
 * 
 * @see org.esigate.esi.EsiRenderer
 * 
 * @author Nicolas Richeton
 */
public class EsiRenderer implements Renderer, FutureAppendable {

    private static final Logger LOG = LoggerFactory.getLogger(EsiRenderer.class);
    /**
     * Key for the executor for future tasks. This is used with parser#setData().
     */
    public static final String DATA_EXECUTOR = "executor";

    private static final Pattern PATTERN = Pattern
            .compile("(<esi:\\w+((\\s+\\w+(\\s*=\\s*(?:\".*?\"|'.*?'|[^'\">\\s]+))?)+\\s*|\\s*)/?>)|(</esi:[^>]*>)");
    private static final Pattern PATTERN_COMMENTS = Pattern.compile("(<!--esi)|(-->)");

    private final FutureParser parser = new FutureParser(PATTERN, IncludeElement.TYPE, CommentElement.TYPE,
            RemoveElement.TYPE, VarsElement.TYPE, ChooseElement.TYPE, WhenElement.TYPE, OtherwiseElement.TYPE,
            TryElement.TYPE, AttemptElement.TYPE, ExceptElement.TYPE, InlineElement.TYPE, ReplaceElement.TYPE,
            FragmentElement.TYPE);

    private final FutureParser parserComments = new FutureParser(PATTERN_COMMENTS, Comment.TYPE);

    private Map<String, CharSequence> fragmentsToReplace;

    private final String page;

    private final String name;

    private boolean write = true;

    private boolean found = false;

    private FutureAppendableAdapter futureOut;

    private Executor executor;

    public String getName() {
        return name;
    }

    public void setWrite(boolean write) {
        this.write = write;
    }

    /**
     * Constructor used to render a complete page.
     * 
     * @param executor
     *            Executor to use for background operations or null if single-thread operations.
     */
    public EsiRenderer(Executor executor) {
        this.page = null;
        this.name = null;
        this.executor = executor;
    }

    /**
     * Constructor used to render a fragment Retrieves a fragment inside a page.<br />
     * 
     * Extracts html between <code><esi:fragment name="myFragment"></code> and <code></esi:fragment></code>
     * 
     * @param page
     * @param name
     * @param executor
     *            Executor to use for background operations or null if single-thread operations.
     */
    public EsiRenderer(String page, String name, Executor executor) {
        this.page = page;
        this.name = name;
        this.write = false;
        this.executor = executor;
    }

    public Map<String, CharSequence> getFragmentsToReplace() {
        return fragmentsToReplace;
    }

    public void setFragmentsToReplace(Map<String, CharSequence> fragmentsToReplace) {
        this.fragmentsToReplace = fragmentsToReplace;
    }

    @Override
    public void render(DriverRequest originalRequest, String content, Writer out) throws IOException, HttpErrorPage {
        if (name != null) {
            LOG.debug("Rendering fragment {} in page {}", name, page);
        }
        this.futureOut = new FutureAppendableAdapter(out);
        if (content == null) {
            return;
        }

        try {
            // Pass 1. Remove esi comments
            StringBuilderFutureAppendable contentWithoutComments = new StringBuilderFutureAppendable();
            parserComments.setHttpRequest(originalRequest);
            parserComments.setData(DATA_EXECUTOR, this.executor);
            parserComments.parse(content, contentWithoutComments);
            CharSequence contentWithoutCommentsResult;

            contentWithoutCommentsResult = contentWithoutComments.get();

            // Pass 2. Process ESI
            parser.setHttpRequest(originalRequest);
            parser.setData(DATA_EXECUTOR, this.executor);
            parser.parse(contentWithoutCommentsResult, this);

            if (name != null && !this.found) {
                throw new HttpErrorPage(HttpStatus.SC_BAD_GATEWAY, "Fragment " + name + " not found", "Fragment "
                        + name + " not found");
            }

            this.futureOut.performAppends();

        } catch (ExecutionException e) {
            throw new IOException(e);
        }
    }

    @Override
    public FutureAppendable enqueueAppend(Future<CharSequence> csq) {
        if (this.write) {
            this.futureOut.enqueueAppend(csq);
        }
        return this;
    }

    public boolean isWrite() {
        return this.write;
    }

    public void setFound(boolean found) {
        this.found = found;

    }

    @Override
    public FutureAppendable performAppends() throws IOException, HttpErrorPage {
        return this.futureOut.performAppends();
    }

    @Override
    public boolean hasPending() {
        return this.futureOut.hasPending();
    }

    @Override
    public FutureAppendable performAppends(int timeout, TimeUnit unit) throws IOException, HttpErrorPage,
            TimeoutException {
        return this.futureOut.performAppends(timeout, unit);
    }

}