com.sun.faces.context.flash.ELFlash Maven / Gradle / Ivy

Go to download
/*
 * 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 com.sun.faces.context.flash;

import com.sun.faces.config.WebConfiguration;
import com.sun.faces.config.WebConfiguration.WebContextInitParameter;
import com.sun.faces.facelets.tag.ui.UIDebug;
import com.sun.faces.util.FacesLogger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.application.Application;
import javax.faces.application.FacesMessage;
import javax.faces.component.UIViewRoot;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.context.Flash;
import javax.faces.event.PhaseId;
import javax.faces.event.PostKeepFlashValueEvent;
import javax.faces.event.PostPutFlashValueEvent;
import javax.faces.event.PreClearFlashEvent;
import javax.faces.event.PreRemoveFlashValueEvent;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * How this implementation works

 * This class is an application singleton.  It has one ivar, {@link
 * #innerMap}.  Entries are added to and removed from this map as needed
 * according to how the flash scope is defined in the spec.  This
 * implementation never touches the session, nor does it cause the
 * session to be created.

 * Most of the hairy logic is encapsulated with in the inner class
 * {@link #PreviousNextFlashInfoManager}.  An instance of this class is
 * obtained by calling one of the variants of getCurrentFlashManager().
 * When the instance is no longer needed for this request, call
 * releaseCurrentFlashManager().

 * Two very important methods are {@link getPhaseMapForWriting} and
 * {@link getPhaseMapForReading}.  These methods are the basis for the
 * Map implementation methods.  Methods that need to write to the map
 * use getPhaseMapForWriting(), those that need to read use
 * getPhaseMapForReading().  These methods allow for the laziness that
 * allows us to only incur a cost when the flash is actually written
 * to.

 * The operation of this class is intimately tied to the request
 * processing lifecycle.  Let's break down every run thru the request
 * processing lifecycle into two parts called "previous" and "next".  We
 * use the names "previous" and "next" to indicate the persistence and
 * timing of the data that is stored in the flash.  Consider two runs
 * through the requset processing lifecle: N and N+1.  On request N,
 * there is no "previous" request.  On Request N, any writes to the
 * flash that happen during RENDER RESPONSE go to the "next" flash map.
 * This means they are available for the ENTIRE run though the request
 * processing lifecycle on request N+1.  Any entries put into the "next"
 * flash map on request N will be expired at the end of request N+1.
 * Now, when we get into request N+1 what was considered "next" on
 * request N, is now called "previous" from the perspective of request
 * N+1.  Any reads from the flash during request N+1 come from the
 * "previous" map.  Any writes to the flash before RENDER RESPONSE go to
 * the "previous" map.  Any writes to the flash during RENDER RESPNOSE
 * go to the "next" map.
 */

public class ELFlash extends Flash {

    // 

    /**
     * Keys in this map are the string version of sequence numbers
     * obtained via calls to {@link #getNewSequenceNumber}.  Values are
     * the actual Map instances that back the actual Map methods on this
     * class.  All writes to and reads from this map are done by the
     * {@link PreviousNextFlashInfoManager} inner class.
     * 
     */
    private Map> flashInnerMap = null;

    private final AtomicLong sequenceNumber = new AtomicLong(0);

    private int numberOfConcurentFlashUsers = Integer.
     parseInt(WebContextInitParameter.NumberOfConcurrentFlashUsers.getDefaultValue());

    private long numberOfFlashesBetweenFlashReapings = Long.
     parseLong(WebContextInitParameter.NumberOfFlashesBetweenFlashReapings.getDefaultValue());
    
    private Application application;

    // 

    // 

    private static final Logger LOGGER = FacesLogger.FLASH.getLogger();

    /**
     * These constants are referenced from other source files in this
     * package.  This one is a disambiguator prefix.
     */
    static final String PREFIX = "csfcf";

    /**
     * This constant is used as the key in the application map that
     * stores the singleton ELFlash instance.
     */
    static final String FLASH_ATTRIBUTE_NAME = PREFIX + "f";

    /**
     * This constant is used as the name of the cookie sent to the
     * client.  The cookie is used to allow the flash scope to
     * be used to support POST REDIRECT GET navigation.
     */
    static final String FLASH_COOKIE_NAME = PREFIX + "c";


    /**
     * This constant is used as the key the request map used, in the
     * FlashELResolver, to convey the name of the property being
     * accessed via 'now'.
     */
    static final String FLASH_NOW_REQUEST_KEY = FLASH_ATTRIBUTE_NAME + "n";

    private enum CONSTANTS {

	/**
	 * The key in the FacesContext attributes map (hereafter
	 * referred to as contextMap) for the request scoped {@link
	 * PreviousNextFlashInfoManager}.
	 */

        RequestFlashManager,

	/**
	 * At the beginning of every phase, we save the value of the
	 * facesContext.getResponseComplete() into the contextMap under
	 * this key.  We check this value after the phase to see if this
	 * is the phase where the user called responseComplete().  This
	 * is important to cover cases when the user does some funny
	 * lifecycle stuff.
	 */

        SavedResponseCompleteFlagValue,

        /**
	 * This is used as the key in the flash itself to store the messages
	 * if they are being tracked.
	 */

        FacesMessageAttributeName,

        /**
	 * This is used as the key in the flash itself to track whether or not
	 * messages are being saved across request/response boundaries.
	 */

        KeepAllMessagesAttributeName,

        /**
         * This key is used in the contextMap to indicate that the next
         * get should be treated as a keep.
         *
         */
        KeepFlagAttributeName,

        /**
         * This key is used in the contextMap to prevent setting the cookie
         * twice.
         */
        DidWriteCookieAttributeName,

    }

    // 

    // 

    /** Creates a new instance of ELFlash */
    private ELFlash() {
        flashInnerMap = new ConcurrentHashMap>();
        WebConfiguration config = WebConfiguration.getInstance();
        String value;
        try {
            value = config.getOptionValue(WebContextInitParameter.NumberOfConcurrentFlashUsers);
            numberOfConcurentFlashUsers = Integer.parseInt(value);
        } catch (NumberFormatException nfe) {
	    if (LOGGER.isLoggable(Level.WARNING)) {
		LOGGER.log(Level.WARNING, "Unable to set number of concurrent flash users.  Defaulting to {0}", numberOfConcurentFlashUsers);
	    }

        }

        try {
            value = config.getOptionValue(WebContextInitParameter.NumberOfFlashesBetweenFlashReapings);
            numberOfFlashesBetweenFlashReapings = Long.parseLong(value);
        } catch (NumberFormatException nfe) {
	    if (LOGGER.isLoggable(Level.WARNING)) {
		LOGGER.log(Level.WARNING, "Unable to set number flashes between flash repaings.  Defaulting to {0}", numberOfFlashesBetweenFlashReapings);
	    }

        }
        
        application = FacesContext.getCurrentInstance().getApplication();

    }

    /**
     * Returns the flash Map for this application.  This is
     * a convenience method that calls
     * FacesContext.getCurrentInstance() and then calls the
     * overloaded getFlash() that takes a
     * FacesContext with it.
     * 
     * @return The flash Map for this session.
     */
    
    public static Map getFlash() {
        FacesContext context = FacesContext.getCurrentInstance();
        return getFlash(context.getExternalContext(), true);
    }

    /**
     *
     * @param extContext the ExternalContext for this request.
     *
     * @param create true to create a new instance for this request if 
     * necessary; false to return null if there's no 
     * instance in the current session.
     * 
     * @return The flash Map for this session.
     */
    
    public static ELFlash getFlash(ExternalContext extContext, boolean create) {
        Map appMap = extContext.getApplicationMap();
        ELFlash flash = (ELFlash) 
            appMap.get(FLASH_ATTRIBUTE_NAME);
        if (null == flash && create) {
            synchronized (extContext.getContext()) {
                if (null == (flash = (ELFlash)
                    appMap.get(FLASH_ATTRIBUTE_NAME))) {
                    flash = new ELFlash();
                    appMap.put(FLASH_ATTRIBUTE_NAME, flash);
                }
            }
        }
        return flash;
    }
    
    // 

    // 

    
    public boolean isKeepMessages() {
        boolean result = false;
        Map phaseMap;

        if (null != (phaseMap = loggingGetPhaseMapForReading(false))) {
            Object value = phaseMap.get(CONSTANTS.KeepAllMessagesAttributeName.toString());
            result = (null != value) ? (Boolean) value : false;
        }
        
        return result;
    }
    
    
    public void setKeepMessages(boolean newValue) {

        loggingGetPhaseMapForWriting(false).put(CONSTANTS.KeepAllMessagesAttributeName.toString(),
                Boolean.valueOf(newValue));

    }
    
    
    public boolean isRedirect() {
        boolean result = false;

        FacesContext context = FacesContext.getCurrentInstance();
        Map contextMap = context.getAttributes();
        PreviousNextFlashInfoManager flashManager;
        if (null != (flashManager = getCurrentFlashManager(contextMap, false))) {
            result = flashManager.getPreviousRequestFlashInfo().isIsRedirect();
        }

        return result;
    }
    

    // PENDING(edburns): I'm going to make an entry to the errata.  This
    // method can't be implemented because the decision of whether or
    // not to redirect is made by the navigationHandler.
    public void setRedirect(boolean newValue) {
    }

    // 

    // 

    
    @SuppressWarnings("element-type-mismatch")
    public Object get(Object key) {
        Object result = null;

        if (null != key) {
            if (key.equals("keepMessages")) {
                result = this.isKeepMessages();
            } else if (key.equals("redirect")) {
                result = this.isRedirect();
            } else {
                FacesContext context = FacesContext.getCurrentInstance();
                if (isKeepFlagSet(context)) {
                    result = getPhaseMapForReading().get(key);
                    keep(key.toString());
                    clearKeepFlag(context);
                    return result;
                }

            }

        }
        
        if (null == result) {
            result = getPhaseMapForReading().get(key);
        }

        if (LOGGER.isLoggable(Level.FINEST)) {
            LOGGER.log(Level.FINEST, "get({0}) = {1}", new Object [] { key, result});
        }

        return result;
    }


    public Object put(String key, Object value) {
        Boolean b = null;
        Object result = null;
        boolean wasSpecialPut = false;

        if (null != key) {
            if (key.equals("keepMessages")) {
                this.setKeepMessages(b = Boolean.parseBoolean((String) value));
                wasSpecialPut = true;
            }
            if (key.equals("redirect")) {
                this.setRedirect(b = Boolean.parseBoolean((String) value));
                wasSpecialPut = true;
            }
        }
        if (!wasSpecialPut) {
            result = (null == b) ? getPhaseMapForWriting().put(key, value) : b;
            if (LOGGER.isLoggable(Level.FINEST)) {
                LOGGER.log(Level.FINEST, "put({0},{1})", new Object [] { key, value});
            }
            application.publishEvent(FacesContext.getCurrentInstance(), PostPutFlashValueEvent.class, key);
        }
        return result;
    }

    @SuppressWarnings("element-type-mismatch")
    public Object remove(Object key) {
        Object result = null;

        application.publishEvent(FacesContext.getCurrentInstance(), PreRemoveFlashValueEvent.class, key);
        result = getPhaseMapForWriting().remove(key);

        return result;
    }

    
    @SuppressWarnings("element-type-mismatch")
    public boolean containsKey(Object key) {
        boolean result = false;

        result = getPhaseMapForReading().containsKey(key);

        return result;
    }

    
    public boolean containsValue(Object value) {
        boolean result = false;

        result = getPhaseMapForReading().containsValue(value);

        return result;
    }

    
    public void putAll(Map t) {

        getPhaseMapForWriting().putAll(t);

    }

    
    public Collection