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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of javax.faces Show documentation
This is the master POM file for Oracle's Implementation of the JSF 2.2 Specification.
There is a newer version: 2.4.0
/*
 * 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.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 static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter.EnableDistributable;
import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter.ForceAlwaysWriteFlashCookie;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.InvalidKeyException;
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.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 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.ByteArrayGuardAESCTR;
import com.sun.faces.util.FacesLogger;

/**
 * How this implementation works

 * This class is an application singleton.  It has one ivar, 
 * 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
 * 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 getPhaseMapForWriting() and
 * 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 final boolean distributable;
    
    private ByteArrayGuardAESCTR guard;
    
    // 

    // 
    
    private static final String ELEMENT_TYPE_MISMATCH = "element-type-mismatch";
    
    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,
        
        /**
         * Force setMaxAge(0)
         */
        ForceSetMaxAgeZero,

    }

    // 

    // 

    /** Creates a new instance of ELFlash */
    private ELFlash(ExternalContext extContext) {
        flashInnerMap = new ConcurrentHashMap<>();
        WebConfiguration config = WebConfiguration.getInstance(extContext);
        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);
	    }

        }
        
        distributable = config.isOptionEnabled(EnableDistributable);
        
        guard = new ByteArrayGuardAESCTR();

    }

    /**
     * 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.
     */
    
    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(extContext);
                    appMap.put(FLASH_ATTRIBUTE_NAME, flash);
                }
            }            
        }
        
        /*
         * If we are in a clustered environment and a session is active, store
         * a helper to ensure our innerMap gets successfully replicated.
         */
        if (appMap.get(EnableDistributable.getQualifiedName()) != null) {
            synchronized (extContext.getContext()) {
                if (extContext.getSession(false) != null) {
                    SessionHelper sessionHelper = SessionHelper.getInstance(extContext);
                    if (sessionHelper == null) {
                        sessionHelper = new SessionHelper();
                    }
                    sessionHelper.update(extContext, flash);
                }
            }
        }
        
        return flash;
    }
    
    // 

    // 

    
    @Override
    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;
    }
    
    
    @Override
    public void setKeepMessages(boolean newValue) {

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

    }
    
    
    @Override
    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.
    @Override
    public void setRedirect(boolean newValue) {
    }

    // 

    // 

    
    @SuppressWarnings(ELEMENT_TYPE_MISMATCH)
    @Override
    public Object get(Object key) {
        Object result = null;

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

            }

        }
        
        if (null == result) {
            result = getPhaseMapForReading().get(key);
        }
        if (distributable && context.getExternalContext().getSession(false) != null) {
            SessionHelper sessionHelper = 
                    SessionHelper.getInstance(context.getExternalContext());
            assert(null != sessionHelper);
            sessionHelper.update(context.getExternalContext(), this);
        }

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

        return result;
    }


    @Override
    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;
            }
        }
        FacesContext context = FacesContext.getCurrentInstance();
        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});
            }
            context.getApplication().publishEvent(context, PostPutFlashValueEvent.class, key);
        }
        if (distributable && context.getExternalContext().getSession(false) != null) {
            SessionHelper sessionHelper = 
                    SessionHelper.getInstance(context.getExternalContext());
            if (sessionHelper != null) {
                sessionHelper.update(context.getExternalContext(), this);
            }
        }
        
        return result;
    }

    @SuppressWarnings(ELEMENT_TYPE_MISMATCH)
    @Override
    public Object remove(Object key) {
        Object result = null;

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

        return result;
    }

    
    @SuppressWarnings(ELEMENT_TYPE_MISMATCH)
    @Override
    public boolean containsKey(Object key) {
        boolean result = false;

        result = getPhaseMapForReading().containsKey(key);

        return result;
    }

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

        result = getPhaseMapForReading().containsValue(value);

        return result;
    }

    
    @Override
    public void putAll(Map t) {

        getPhaseMapForWriting().putAll(t);

    }

    
    @Override
    public Collection