Class AbstractSessionDataStore

    • Field Detail

      • DEFAULT_GRACE_PERIOD_SEC

        public static final int DEFAULT_GRACE_PERIOD_SEC
        See Also:
        Constant Field Values
      • DEFAULT_SAVE_PERIOD_SEC

        public static final int DEFAULT_SAVE_PERIOD_SEC
        See Also:
        Constant Field Values
      • _gracePeriodSec

        protected int _gracePeriodSec
      • _lastExpiryCheckTime

        protected long _lastExpiryCheckTime
      • _lastOrphanSweepTime

        protected long _lastOrphanSweepTime
      • _savePeriodSec

        protected int _savePeriodSec
    • Constructor Detail

      • AbstractSessionDataStore

        public AbstractSessionDataStore()
    • Method Detail

      • doExists

        public abstract boolean doExists​(java.lang.String id)
                                  throws java.lang.Exception
        Check if a session for the given id exists.
        Parameters:
        id - the session id to check
        Returns:
        true if the session exists in the persistent store, false otherwise
        Throws:
        java.lang.Exception
      • doStore

        public abstract void doStore​(java.lang.String id,
                                     SessionData data,
                                     long lastSaveTime)
                              throws java.lang.Exception
        Store the session data persistently.
        Parameters:
        id - identity of session to store
        data - info of the session
        lastSaveTime - time of previous save or 0 if never saved
        Throws:
        java.lang.Exception - if unable to store data
      • doLoad

        public abstract SessionData doLoad​(java.lang.String id)
                                    throws java.lang.Exception
        Load the session from persistent store.
        Parameters:
        id - the id of the session to load
        Returns:
        the re-inflated session
        Throws:
        java.lang.Exception - if unable to load the session
      • doCheckExpired

        public abstract java.util.Set<java.lang.String> doCheckExpired​(java.util.Set<java.lang.String> candidates,
                                                                       long time)
        Implemented by subclasses to resolve which sessions in this context that are being managed by this node that should be expired.
        Parameters:
        candidates - the ids of sessions the SessionCache thinks has expired
        time - the time at which to check for expiry
        Returns:
        the reconciled set of session ids that have been checked in the store
      • doGetExpired

        public abstract java.util.Set<java.lang.String> doGetExpired​(long before)
        Implemented by subclasses to find sessions for this context in the store that expired at or before the time limit and thus not being actively managed by any node. This method is only called periodically (the period is configurable) to avoid putting too much load on the store.
        Parameters:
        before - the upper limit of expiry times to check. Sessions expired at or before this timestamp will match.
        Returns:
        the empty set if there are no sessions expired as at the time, or otherwise a set of session ids.
      • doCleanOrphans

        public abstract void doCleanOrphans​(long time)
        Implemented by subclasses to delete sessions for other contexts that expired at or before the timeLimit. These are 'orphaned' sessions that are no longer being actively managed by any node. These are explicitly sessions that do NOT belong to this context (other mechanisms such as doGetExpired take care of those). As they don't belong to this context, they cannot be loaded by us. This is called only periodically to avoid placing excessive load on the store.
        Parameters:
        time - the upper limit of the expiry time to check in msec
      • initialize

        public void initialize​(SessionContext context)
                        throws java.lang.Exception
        Description copied from interface: SessionDataMap
        Initialize this data map for the given context. A SessionDataMap can only be used by one context(/session manager).
        Specified by:
        initialize in interface SessionDataMap
        Parameters:
        context - context associated
        Throws:
        java.lang.Exception - if unable to initialize the
      • cleanOrphans

        public void cleanOrphans​(long timeLimit)
        Remove all sessions for any context that expired at or before the given time.
        Parameters:
        timeLimit - the time before which the sessions must have expired.
      • load

        public SessionData load​(java.lang.String id)
                         throws java.lang.Exception
        Description copied from interface: SessionDataMap
        Read in session data.
        Specified by:
        load in interface SessionDataMap
        Parameters:
        id - identity of session to load
        Returns:
        the SessionData matching the id
        Throws:
        java.lang.Exception - if unable to load session data
      • store

        public void store​(java.lang.String id,
                          SessionData data)
                   throws java.lang.Exception
        Description copied from interface: SessionDataMap
        Store the session data.
        Specified by:
        store in interface SessionDataMap
        Parameters:
        id - identity of session to store
        data - info of session to store
        Throws:
        java.lang.Exception - if unable to write session data
      • exists

        public boolean exists​(java.lang.String id)
                       throws java.lang.Exception
        Description copied from interface: SessionDataStore
        Test if data exists for a given session id.
        Specified by:
        exists in interface SessionDataStore
        Parameters:
        id - Identity of session whose existence should be checked
        Returns:
        true if valid, non-expired session exists
        Throws:
        java.lang.Exception - if problem checking existence with persistence layer
      • getExpired

        public java.util.Set<java.lang.String> getExpired​(java.util.Set<java.lang.String> candidates)
        Description copied from interface: SessionDataStore
        Called periodically, this method should search the data store for sessions that have been expired for a 'reasonable' amount of time.
        Specified by:
        getExpired in interface SessionDataStore
        Parameters:
        candidates - if provided, these are keys of sessions that the SessionDataStore thinks has expired and should be verified by the SessionDataStore
        Returns:
        set of session ids
      • newSessionData

        public SessionData newSessionData​(java.lang.String id,
                                          long created,
                                          long accessed,
                                          long lastAccessed,
                                          long maxInactiveMs)
        Description copied from interface: SessionDataStore
        Create a new SessionData
        Specified by:
        newSessionData in interface SessionDataStore
        Parameters:
        id - the id
        created - the timestamp when created
        accessed - the timestamp when accessed
        lastAccessed - the timestamp when last accessed
        maxInactiveMs - the max inactive time in milliseconds
        Returns:
        a new SessionData object
      • checkStarted

        protected void checkStarted()
                             throws java.lang.IllegalStateException
        Throws:
        java.lang.IllegalStateException
      • doStart

        protected void doStart()
                        throws java.lang.Exception
        Description copied from class: ContainerLifeCycle
        Starts the managed lifecycle beans in the order they were added.
        Overrides:
        doStart in class ContainerLifeCycle
        Throws:
        AbstractLifeCycle.StopException - If thrown, the lifecycle will immediately be stopped.
        java.lang.Exception - If there was a problem starting. Will cause a transition to FAILED state
      • getGracePeriodSec

        @ManagedAttribute(value="interval in secs to prevent too eager session scavenging",
                          readonly=true)
        public int getGracePeriodSec()
      • setGracePeriodSec

        public void setGracePeriodSec​(int sec)
      • setSavePeriodSec

        public void setSavePeriodSec​(int savePeriodSec)
        The minimum time in seconds between save operations. Saves normally occur every time the last request exits as session. If nothing changes on the session except for the access time and the persistence technology is slow, this can cause delays.

        By default the value is 0, which means we save after the last request exists. A non zero value means that we will skip doing the save if the session isn't dirty if the elapsed time since the session was last saved does not exceed this value.

        Parameters:
        savePeriodSec - the savePeriodSec to set