Glassfish example source code file (RestrictedContentAdapter.java)

This example Glassfish source code file (RestrictedContentAdapter.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Glassfish tags/keywords

grizzlyresponse, grizzlyresponse, http, io, ioexception, ioexception, log, logging, map, request, restrictedcontentadapter, runtimeexception, servlet, state, static, staticcontent, staticcontent, string, string, uri

The Glassfish RestrictedContentAdapter.java source code

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package org.glassfish.appclient.server.core.jws;

import com.sun.grizzly.tcp.http11.GrizzlyAdapter;
import com.sun.grizzly.tcp.http11.GrizzlyRequest;
import com.sun.grizzly.tcp.http11.GrizzlyResponse;
import com.sun.logging.LogDomains;
import java.io.File;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.http.HttpServletResponse;
import org.glassfish.appclient.server.core.jws.servedcontent.Content;
import org.glassfish.appclient.server.core.jws.servedcontent.StaticContent;

/**
 *
 * @author tjquinn
 */
public class RestrictedContentAdapter extends GrizzlyAdapter {

    protected final static String LAST_MODIFIED_HEADER_NAME = "Last-Modified";
    protected final static String DATE_HEADER_NAME = "Date";
    protected final static String IF_MODIFIED_SINCE = "If-Modified-Since";

    private final static String LINE_SEP = System.getProperty("line.separator");
    
    private final Logger logger = LogDomains.getLogger(
            RestrictedContentAdapter.class, LogDomains.ACC_LOGGER);

    private enum State {
        RESUMED,
        SUSPENDED
    }

    private volatile State state = State.RESUMED;

    private final String contextRoot;

    private final ConcurrentHashMap<String,StaticContent> content =
            new ConcurrentHashMap<String,StaticContent>();

    public RestrictedContentAdapter(
            final String contextRoot,
            final Map<String,StaticContent> content) throws IOException {
        this(contextRoot);
        this.content.putAll(content);
        /*
         * Preload the adapter's cache with the static content.  This helps
         * performance but is essential to the operation of the adapter.
         * Normally the Grizzly logic will qualify the URI in the request
         * with the root folder of the adapter.  But the files this
         * adapter needs to serve can come from a variety of places that
         * might not share any common parent directory for the root folder.
         * Preloading the cache with the known static content lets the Grizzly
         * logic serve the files we want, from whereever they are.
         */
        for (Map.Entry<String,StaticContent> sc : content.entrySet()) {
            cache.put(sc.getKey(), sc.getValue().file());
        }
        logger.fine(logPrefix() + "Initial static content loaded " +
                dumpContent());
    }

    public RestrictedContentAdapter(final String contextRoot) {
        /*
         * Turn off the default static resource handling.  We do our own from
         * our service method, rather than letting the StaticResourcesAdapter
         * (superclass) logic have a try at each request first.
         */
        this.contextRoot = contextRoot;
//        this.userFriendlyContextRoot = userFriendlyContextRoot;
        setHandleStaticResources(false);

        setUseSendFile(false);
        commitErrorResponse = true;
    }

    @Override
    public void service(GrizzlyRequest gReq, GrizzlyResponse gResp) {
        try {
            if (!serviceContent(gReq, gResp)) {
                respondNotFound(gResp);
            }
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    }

    public String contextRoot() {
        return contextRoot;
    }

//    public String userFriendlyContextRoot() {
//        return userFriendlyContextRoot;
//    }

    public synchronized void addContentIfAbsent(final String relativeURIString,
            final StaticContent newContent) throws IOException {
        final StaticContent existingContent = content.get(relativeURIString);
        if (existingContent != null) {
            if ( ! existingContent.equals(newContent)) {
                logger.log(Level.FINE, "enterprise.deployment.appclient.jws.staticContentCollision",
                        new Object[] {relativeURIString, newContent.toString()});
            }
            return;
        }
        this.content.put(relativeURIString, newContent);
        this.cache.put(relativeURIString, newContent.file());
        logger.fine(logPrefix() + "adding static content " +
                relativeURIString + " " + newContent.toString());
    }

    public synchronized void addContentIfAbsent(
            final Map<String,StaticContent> staticContent) throws IOException {
        for (Map.Entry<String,StaticContent> entry : staticContent.entrySet()) {
            addContentIfAbsent(entry.getKey(), entry.getValue());
        }
    }


//    protected String relativizeURIString(final String uriString) {
//        String result;
//        if ( (result = relativizeURIString(contextRoot, uriString)) == null) {
//            if ( ( result = relativizeURIString(userFriendlyContextRoot, uriString)) == null) {
//                logger.log(Level.WARNING, "enterprise.deployment.appclient.jws.uriOutsideContextRoot",
//                    new Object[] {uriString, contextRoot, userFriendlyContextRoot});
//                return null;
//            }
//        }
//        return result;
//    }

    protected String relativizeURIString(final String candidateContextRoot,
            final String uriString) {
        if ( ! uriString.startsWith(candidateContextRoot)) {
            return null;
        }
        /*
         * If the user has requested the main JNLP using the user-friendly
         * context root then there candidate context root is exactly the
         * same as the context root.  There will be no substring after
         * that.
         */
        if (candidateContextRoot.equals(uriString)) {
            return "";
        }
        return uriString.substring(candidateContextRoot.length() + 1);
    }

    protected boolean serviceContent(GrizzlyRequest gReq, GrizzlyResponse gResp) throws IOException {

        String relativeURIString = relativizeURIString(contextRoot, gReq.getRequestURI());

        /*
         * "Forbidden" seems like a more helpful response than "not found"
         * if the corresponding app client has been suspended.
         */
        if (state == State.SUSPENDED) {
            finishErrorResponse(gResp, HttpServletResponse.SC_FORBIDDEN);
            logger.fine(logPrefix() + "is suspended; refused to serve static content requested using "
                    + (relativeURIString == null ? "null" : relativeURIString));
            return true;
        }

        if (relativeURIString == null) {
            logger.fine(logPrefix() + "Could not find static content requested using full request URI = "
                    + gReq.getRequestURI() + " - relativized URI was null");
            respondNotFound(gResp);
            return true;
        }
        /*
         * The Grizzly-managed cache could contain entries for non-existent
         * files that users request.  If the URI indicates it's a request for
         * static content make sure the requested URI is in the predefined staticContent
         * before having Grizzly serve it.
         *
         * Alternatively, if the URI indicates the request is for dynamic content
         * then handle that separately.
         *
         * If the request is for a URI in neither the static nor dynamic
         * content this adapter should serve, then just return a 404.
         */
        final StaticContent sc = content.get(relativeURIString);
        if (sc != null && sc.isAvailable()) {
            processContent(relativeURIString, gReq, gResp);
            return true;
        } else {
            finishErrorResponse(gResp, contentStateToResponseStatus(sc));
            final String scString = (sc == null ? "null" : sc.toString());
            final String scStateString = (sc == null ? "null" : sc.state().toString());
            logger.fine(logPrefix() + "Found static content for " + gReq.getMethod() +
                    ": " + relativeURIString + " -> " + scString +
                    " but could not serve it; its state is " + scStateString);
            return true;
        }
    }

    private void processContent(final String relativeURIString,
            final GrizzlyRequest gReq, final GrizzlyResponse gResp) {
        try {
            final StaticContent sc = content.get(relativeURIString);

            /*
             * No need to actually send the file if the request contains a
             * If-Modified-Since date and the file is not more recent.
             */
            final File fileToSend = sc.file();
            if (fileToSend != null) {
                if (returnIfClientCacheIsCurrent(relativeURIString,
                        gReq, fileToSend.lastModified())) {
                    return;
                }

                /*
                 * The client's cache is obsolete.  Be sure to set the
                 * time header values.
                 */
                gResp.addDateHeader(LAST_MODIFIED_HEADER_NAME, fileToSend.lastModified());
                gResp.addDateHeader(DATE_HEADER_NAME, System.currentTimeMillis());
            }

            /*
             * Delegate to the Grizzly implementation.
             */
            super.service(relativeURIString, gReq.getRequest(), gResp.getResponse());
            final int status = gResp.getStatus();
            if (status != HttpServletResponse.SC_OK) {
                logger.fine(logPrefix() + "Could not serve content for " +
                        relativeURIString + " - status = " + status);
            } else {
                logger.fine(logPrefix() + "Served static content for " + gReq.getMethod() +
                        ":" + sc.toString());
            }
            finishResponse(gResp, status);
        } catch (Exception e) {
//            gResp.getResponse().setErrorException(e);
//            finishErrorResponse(gResp, HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
            logger.log(Level.SEVERE, logPrefix() + relativeURIString, e);
        }
    }

    protected boolean returnIfClientCacheIsCurrent(final String relativeURIString,
            final GrizzlyRequest gReq,
            final long contentTimestamp) {
        final long ifModifiedSinceTime = gReq.getDateHeader(IF_MODIFIED_SINCE);
        boolean result;
        if (result = (ifModifiedSinceTime != -1) &&
            (ifModifiedSinceTime >= contentTimestamp)) {
            finishSuccessResponse(gReq.getResponse(), 
                    HttpServletResponse.SC_NOT_MODIFIED);
            logger.fine(logPrefix() + relativeURIString + " is already current on the client; no downloaded needed");
        }
        return result;
    }

    protected int contentStateToResponseStatus(Content content) throws IOException {
        int status;
        if (content == null) {
            status = HttpServletResponse.SC_NOT_FOUND;
        } else if (content.isAvailable()) {
            status = HttpServletResponse.SC_OK;
        } else {
            status = (content.state() == Content.State.SUSPENDED
                        ? HttpServletResponse.SC_FORBIDDEN
                        : HttpServletResponse.SC_NOT_FOUND);
        }
        return status;
    }
    
    public void suspend() {
        state = State.SUSPENDED;
    }

    public void resume() {
        state = State.RESUMED;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder(logPrefix()).append(LINE_SEP);
        for (Map.Entry<String,StaticContent> entry : content.entrySet()) {
            sb.append("  ").append(entry.toString()).append(LINE_SEP);
        }
        return sb.toString();
    }


    protected void finishResponse(final GrizzlyResponse gResp, final int status) {
        gResp.setStatus(status);
        try {
            gResp.finishResponse();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    protected void respondNotFound(final GrizzlyResponse gResp) {
        finishErrorResponse(gResp, HttpServletResponse.SC_NOT_FOUND);
    }

    protected void finishSuccessResponse(final GrizzlyResponse gResp, final int status) {
        finishResponse(gResp, status, false);
    }

    private void finishResponse(final GrizzlyResponse gResp, final int status,
            final boolean treatAsError) {
        gResp.setStatus(status);
        try {
            if (treatAsError && commitErrorResponse) {
                customizedErrorPage(gResp.getRequest().getRequest(), gResp.getResponse());
            }
            gResp.finishResponse();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    protected void finishErrorResponse(final GrizzlyResponse gResp, final int status) {
        finishResponse(gResp, status, true);
    }

    protected String dumpContent() {
        if (content == null) {
            return "  Static content: not initialized";
        }
        if (content.isEmpty()) {
            return "  Static content: empty" + LINE_SEP;
        }
        final StringBuilder sb = new StringBuilder(LINE_SEP).append("  Static content");
        for (Map.Entry<String,StaticContent> entry : content.entrySet()) {
            sb.append("  ").append(entry.getKey()).append(" : ").
                    append(entry.getValue().toString()).append(LINE_SEP);
        }
        sb.append(LINE_SEP).append("  ========");
        return sb.toString();
    }

    protected String logPrefix() {
        return "Adapter[" + contextRoot + "] ";
    }
}