Class AbstractSessionCache

  • All Implemented Interfaces:
    SessionCache, Container, Destroyable, Dumpable, LifeCycle
    Direct Known Subclasses:
    DefaultSessionCache, NullSessionCache

    @ManagedObject
    public abstract class AbstractSessionCache
    extends ContainerLifeCycle
    implements SessionCache
    AbstractSessionCache A base implementation of the SessionCache interface for managing a set of Session objects pertaining to a context in memory. This implementation ensures that multiple requests for the same session id always return the same Session object. It will delay writing out a session to the SessionDataStore until the last request exits the session. If the SessionDataStore supports passivation then the session passivation and activation listeners are called appropriately as the session is written. This implementation also supports evicting idle Session objects. An idle Session is one that is still valid, has not expired, but has not been accessed by a request for a configurable amount of time. An idle session will be first passivated before it is evicted from the cache.
    • Field Detail

      • _sessionDataStore

        protected SessionDataStore _sessionDataStore
        The authoritative source of session data
      • _handler

        protected final SessionHandler _handler
        The SessionHandler related to this SessionCache
      • _context

        protected SessionContext _context
        Information about the context to which this SessionCache pertains
      • _evictionPolicy

        protected int _evictionPolicy
        When, if ever, to evict sessions: never; only when the last request for them finishes; after inactivity time (expressed as secs)
      • _saveOnCreate

        protected boolean _saveOnCreate
        If true, as soon as a new session is created, it will be persisted to the SessionDataStore
      • _saveOnInactiveEviction

        protected boolean _saveOnInactiveEviction
        If true, a session that will be evicted from the cache because it has been inactive too long will be saved before being evicted.
      • _removeUnloadableSessions

        protected boolean _removeUnloadableSessions
        If true, a Session whose data cannot be read will be deleted from the SessionDataStore.
      • _flushOnResponseCommit

        protected boolean _flushOnResponseCommit
        If true, when a response is about to be committed back to the client, a dirty session will be flushed to the session store.
    • Method Detail

      • newSession

        public abstract Session newSession​(SessionData data)
        Create a new Session object from pre-existing session data
        Specified by:
        newSession in interface SessionCache
        Parameters:
        data - the session data
        Returns:
        a new Session object
      • newSession

        public abstract Session newSession​(javax.servlet.http.HttpServletRequest request,
                                           SessionData data)
        Create a new Session for a request.
        Parameters:
        request - the request
        data - the session data
        Returns:
        the new session
      • doGet

        protected abstract Session doGet​(java.lang.String id)
        Get the session matching the key from the cache. Does not load the session.
        Parameters:
        id - session id
        Returns:
        the Session object matching the id
      • doPutIfAbsent

        protected abstract Session doPutIfAbsent​(java.lang.String id,
                                                 Session session)
        Put the session into the map if it wasn't already there
        Parameters:
        id - the identity of the session
        session - the session object
        Returns:
        null if the session wasn't already in the map, or the existing entry otherwise
      • doComputeIfAbsent

        protected abstract Session doComputeIfAbsent​(java.lang.String id,
                                                     java.util.function.Function<java.lang.String,​Session> mappingFunction)
        Compute the mappingFunction to create a Session object iff the session with the given id isn't already in the map, otherwise return the existing Session. This method is expected to have precisely the same behaviour as ConcurrentHashMap.computeIfAbsent(K, java.util.function.Function<? super K, ? extends V>)
        Parameters:
        id - the session id
        mappingFunction - the function to load the data for the session
        Returns:
        an existing Session from the cache
      • doReplace

        protected abstract boolean doReplace​(java.lang.String id,
                                             Session oldValue,
                                             Session newValue)
        Replace the mapping from id to oldValue with newValue
        Parameters:
        id - the id
        oldValue - the old value
        newValue - the new value
        Returns:
        true if replacement was done
      • doDelete

        public abstract Session doDelete​(java.lang.String id)
        Remove the session with this identity from the store
        Parameters:
        id - the id
        Returns:
        Session that was removed or null
      • setEvictionPolicy

        public void setEvictionPolicy​(int evictionTimeout)
        -1 means we never evict inactive sessions. 0 means we evict a session after the last request for it exits >0 is the number of seconds after which we evict inactive sessions from the cache
        Specified by:
        setEvictionPolicy in interface SessionCache
        Parameters:
        evictionTimeout - -1 is never evict; 0 is evict-on-exit; and any other positive value is the time in seconds that a session can be idle before it can be evicted.
        See Also:
        SessionCache.setEvictionPolicy(int)
      • setSaveOnCreate

        public void setSaveOnCreate​(boolean saveOnCreate)
        Description copied from interface: SessionCache
        Whether or not a session that is newly created should be immediately saved. If false, a session that is created and invalidated within a single request is never persisted.
        Specified by:
        setSaveOnCreate in interface SessionCache
        Parameters:
        saveOnCreate - true to immediately save the newly created session
      • setRemoveUnloadableSessions

        public void setRemoveUnloadableSessions​(boolean removeUnloadableSessions)
        If a session's data cannot be loaded from the store without error, remove it from the persistent store.
        Specified by:
        setRemoveUnloadableSessions in interface SessionCache
        Parameters:
        removeUnloadableSessions - if true unloadable sessions will be removed from session store
      • setFlushOnResponseCommit

        public void setFlushOnResponseCommit​(boolean flushOnResponseCommit)
        Description copied from interface: SessionCache
        If true, a dirty session will be written to the SessionDataStore just before a response is returned to the client. This ensures that subsequent requests to either the same node or a different node see the changed session data.
        Specified by:
        setFlushOnResponseCommit in interface SessionCache
      • isFlushOnResponseCommit

        public boolean isFlushOnResponseCommit()
        Specified by:
        isFlushOnResponseCommit in interface SessionCache
        Returns:
        true if dirty sessions should be written before the response is committed.
      • get

        public Session get​(java.lang.String id)
                    throws java.lang.Exception
        Get a session object. If the session object is not in this session store, try getting the data for it from a SessionDataStore associated with the session manager. The usage count of the session is incremented.
        Specified by:
        get in interface SessionCache
        Parameters:
        id - the session id
        Returns:
        the Session if one exists, null otherwise
        Throws:
        java.lang.Exception - if any error occurred
        See Also:
        SessionCache.get(java.lang.String)
      • getAndEnter

        protected Session getAndEnter​(java.lang.String id,
                                      boolean enter)
                               throws java.lang.Exception
        Get a session object. If the session object is not in this session store, try getting the data for it from a SessionDataStore associated with the session manager.
        Parameters:
        id - The session to retrieve
        enter - if true, the usage count of the session will be incremented
        Returns:
        Throws:
        java.lang.Exception
      • add

        public void add​(java.lang.String id,
                        Session session)
                 throws java.lang.Exception
        Add an entirely new session (created by the application calling Request.getSession(true)) to the cache. The usage count of the fresh session is incremented.
        Specified by:
        add in interface SessionCache
        Parameters:
        id - the id
        session -
        Throws:
        java.lang.Exception
      • commit

        public void commit​(Session session)
                    throws java.lang.Exception
        A response that has accessed this session is about to be returned to the client. Pass the session to the store to persist, so that any changes will be visible to subsequent requests on the same node (if using NullSessionCache), or on other nodes.
        Specified by:
        commit in interface SessionCache
        Throws:
        java.lang.Exception
      • put

        public void put​(java.lang.String id,
                        Session session)
                 throws java.lang.Exception
        Deprecated.
        Description copied from interface: SessionCache
        Finish using a Session. This is called by the SessionHandler once a request is finished with a Session. SessionCache implementations may want to delay writing out Session contents until the last request exits a Session.
        Specified by:
        put in interface SessionCache
        Parameters:
        id - the session id
        session - the current session object
        Throws:
        java.lang.Exception - if any error occurred
        See Also:
        SessionCache.release(java.lang.String,org.eclipse.jetty.server.session.Session)
      • release

        public void release​(java.lang.String id,
                            Session session)
                     throws java.lang.Exception
        Finish using the Session object. This should be called when a request exists the session. Only when the last simultaneous request exists the session will any action be taken. If there is a SessionDataStore write the session data through to it. If the SessionDataStore supports passivation, call the passivate/active listeners. If the evictionPolicy == SessionCache.EVICT_ON_SESSION_EXIT then after we have saved the session, we evict it from the cache.
        Specified by:
        release in interface SessionCache
        Parameters:
        id - the session id
        session - the current session object
        Throws:
        java.lang.Exception - if any error occurred
        See Also:
        SessionCache.release(java.lang.String, org.eclipse.jetty.server.session.Session)
      • exists

        public boolean exists​(java.lang.String id)
                       throws java.lang.Exception
        Check to see if a session corresponding to the id exists. This method will first check with the object store. If it doesn't exist in the object store (might be passivated etc), it will check with the data store.
        Specified by:
        exists in interface SessionCache
        Parameters:
        id - the session id
        Returns:
        true if the session exists, false otherwise
        Throws:
        java.lang.Exception - the Exception
        See Also:
        SessionCache.exists(java.lang.String)
      • contains

        public boolean contains​(java.lang.String id)
                         throws java.lang.Exception
        Check to see if this cache contains an entry for the session corresponding to the session id.
        Specified by:
        contains in interface SessionCache
        Parameters:
        id - the session id
        Returns:
        true if a Session object matching the id is present in the cache, false otherwise
        Throws:
        java.lang.Exception - if any error occurred
        See Also:
        SessionCache.contains(java.lang.String)
      • delete

        public Session delete​(java.lang.String id)
                       throws java.lang.Exception
        Remove a session object from this store and from any backing store.
        Specified by:
        delete in interface SessionCache
        Parameters:
        id - the session id
        Returns:
        the Session that was removed, null otherwise
        Throws:
        java.lang.Exception - if any error occurred
        See Also:
        SessionCache.delete(java.lang.String)
      • checkExpiration

        public java.util.Set<java.lang.String> checkExpiration​(java.util.Set<java.lang.String> candidates)
        Description copied from interface: SessionCache
        Check a list of session ids that belong to potentially expired sessions. The Session in the cache should be checked, but also the SessionDataStore, as that is the authoritative source of all session information.
        Specified by:
        checkExpiration in interface SessionCache
        Parameters:
        candidates - the session ids to check
        Returns:
        the set of session ids that have actually expired: this can be a superset of the original candidate list.
        See Also:
        SessionCache.checkExpiration(Set)
      • checkInactiveSession

        public void checkInactiveSession​(Session session)
        Check a session for being inactive and thus being able to be evicted, if eviction is enabled.
        Specified by:
        checkInactiveSession in interface SessionCache
        Parameters:
        session - session to check
      • renewSessionId

        public Session renewSessionId​(java.lang.String oldId,
                                      java.lang.String newId,
                                      java.lang.String oldExtendedId,
                                      java.lang.String newExtendedId)
                               throws java.lang.Exception
        Description copied from interface: SessionCache
        Change the id of a Session.
        Specified by:
        renewSessionId in interface SessionCache
        Parameters:
        oldId - the current session id
        newId - the new session id
        oldExtendedId - the current extended session id
        newExtendedId - the new extended session id
        Returns:
        the Session after changing its id
        Throws:
        java.lang.Exception - if any error occurred
      • renewSessionId

        protected void renewSessionId​(Session session,
                                      java.lang.String newId,
                                      java.lang.String newExtendedId)
                               throws java.lang.Exception
        Swap the id on a session.
        Parameters:
        session - the session for which to do the swap
        newId - the new id
        newExtendedId - the full id plus node id
        Throws:
        java.lang.Exception - if there was a failure saving the change
      • isSaveOnInactiveEviction

        @ManagedAttribute(value="save sessions before evicting from cache",
                          readonly=true)
        public boolean isSaveOnInactiveEviction()
        Whether we should save a session that has been inactive before we boot it from the cache.
        Specified by:
        isSaveOnInactiveEviction in interface SessionCache
        Returns:
        true if an inactive session will be saved before being evicted