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

/*
 * Copyright (c) 1997, 2020 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 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;

import jakarta.faces.application.FacesMessage;
import jakarta.faces.component.UIViewRoot;
import jakarta.faces.context.ExternalContext;
import jakarta.faces.context.FacesContext;
import jakarta.faces.context.Flash;
import jakarta.faces.event.PhaseId;
import jakarta.faces.event.PostKeepFlashValueEvent;
import jakarta.faces.event.PostPutFlashValueEvent;
import jakarta.faces.event.PreClearFlashEvent;
import jakarta.faces.event.PreRemoveFlashValueEvent;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;

/**
 * 
 * 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 = isKeepMessages();
            } else if (key.equals("redirect")) {
                result = 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());
            if (sessionHelper != null) {
                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")) {
                setKeepMessages(b = Boolean.parseBoolean((String) value));
                wasSpecialPut = true;
            }
            if (key.equals("redirect")) {
                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