• Home
• jakarta.faces
• jakarta.faces-api
• 2.3.1
• source code
• ELFlash.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

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

/*
 * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */

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