Class MongoSessionDataStore

  • All Implemented Interfaces:
    SessionDataMap, SessionDataStore, Container, Destroyable, Dumpable, Dumpable.DumpableContainer, LifeCycle

    @ManagedObject
    public class MongoSessionDataStore
    extends NoSqlSessionDataStore
    MongoSessionDataStore The document model is an outer object that contains the elements:
    • "id" : session_id
    • "created" : create_time
    • "accessed": last_access_time
    • "maxIdle" : max_idle_time setting as session was created
    • "expiry" : time at which session should expire
    • "valid" : session_valid
    • "context" : a nested object containing 1 nested object per context for which the session id is in use
    Each of the nested objects inside the "context" element contains:
    • unique_context_name : nested object containing name:value pairs of the session attributes for that context
    • unique_context_name: vhost:contextpath, where no vhosts="0_0_0_0", root context = "", contextpath "/" replaced by "_"

    One of the name:value attribute pairs will always be the special attribute "__metadata__". The value is an object representing a version counter which is incremented every time the attributes change.

    For example:

     { "_id"       : ObjectId("52845534a40b66410f228f23"),
        "accessed" :  NumberLong("1384818548903"),
        "maxIdle"  : 1,
        "context"  : { "0_0_0_0:_testA" : { "A"            : "A",
                                         "__metadata__" : { "version" : NumberLong(2) }
                                       },
                       "0_0_0_0:_testB" : { "B"            : "B",
                                         "__metadata__" : { "version" : NumberLong(1) }
                                       }
                     },
        "created"  : NumberLong("1384818548903"),
        "expiry"   : NumberLong("1384818549903"),
        "id"       : "w01ijx2vnalgv1sqrpjwuirprp7",
        "valid"    : true
     }
     

    In MongoDB, the nesting level is indicated by "." separators for the key name. Thus to interact with session fields, the key is composed of: "context".unique_context_name.field_name Eg "context"."0_0_0_0:_testA"."lastSaved"

    • Field Detail

      • __METADATA

        public static final java.lang.String __METADATA
        Special attribute for a session that is context-specific
        See Also:
        Constant Field Values
      • __CONTEXT

        public static final java.lang.String __CONTEXT
        Name of nested document field containing 1 sub document per context for which the session id is in use
        See Also:
        Constant Field Values
      • __VERSION

        public static final java.lang.String __VERSION
        Special attribute per session per context, incremented each time attributes are modified
        See Also:
        Constant Field Values
      • __ACCESSED

        public static final java.lang.String __ACCESSED
        Last access time of session
        See Also:
        Constant Field Values
      • __EXPIRY

        public static final java.lang.String __EXPIRY
        Time this session will expire, based on last access time and maxIdle
        See Also:
        Constant Field Values
      • __MAX_IDLE

        public static final java.lang.String __MAX_IDLE
        The max idle time of a session (smallest value across all contexts which has a session with the same id)
        See Also:
        Constant Field Values
      • __CREATED

        public static final java.lang.String __CREATED
        Time of session creation
        See Also:
        Constant Field Values
      • __VALID

        public static final java.lang.String __VALID
        Whether or not session is valid
        See Also:
        Constant Field Values
    • Constructor Detail

      • MongoSessionDataStore

        public MongoSessionDataStore()
    • Method Detail

      • setDBCollection

        public void setDBCollection​(com.mongodb.DBCollection collection)
      • doLoad

        public SessionData doLoad​(java.lang.String id)
                           throws java.lang.Exception
        Description copied from class: AbstractSessionDataStore
        Load the session from persistent store.
        Specified by:
        doLoad in class AbstractSessionDataStore
        Parameters:
        id - the id of the session to load
        Returns:
        the re-inflated session
        Throws:
        java.lang.Exception - if unable to load the session
      • delete

        public boolean delete​(java.lang.String id)
                       throws java.lang.Exception
        Description copied from interface: SessionDataMap
        Delete session data
        Parameters:
        id - identity of session to delete
        Returns:
        true if the session was deleted
        Throws:
        java.lang.Exception - if unable to delete session data
      • doExists

        public boolean doExists​(java.lang.String id)
                         throws java.lang.Exception
        Description copied from class: AbstractSessionDataStore
        Check if a session for the given id exists.
        Specified by:
        doExists in class AbstractSessionDataStore
        Parameters:
        id - the session id to check
        Returns:
        true if the session exists in the persistent store, false otherwise
        Throws:
        java.lang.Exception
      • doCheckExpired

        public java.util.Set<java.lang.String> doCheckExpired​(java.util.Set<java.lang.String> candidates,
                                                              long time)
        Description copied from class: AbstractSessionDataStore
        Implemented by subclasses to resolve which sessions in this context that are being managed by this node that should be expired.
        Specified by:
        doCheckExpired in class AbstractSessionDataStore
        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 java.util.Set<java.lang.String> doGetExpired​(long timeLimit)
        Description copied from class: AbstractSessionDataStore
        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.
        Specified by:
        doGetExpired in class AbstractSessionDataStore
        Parameters:
        timeLimit - 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 void doCleanOrphans​(long timeLimit)
        Description copied from class: AbstractSessionDataStore
        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.
        Specified by:
        doCleanOrphans in class AbstractSessionDataStore
        Parameters:
        timeLimit - the upper limit of the expiry time to check in msec
      • doStore

        public void doStore​(java.lang.String id,
                            SessionData data,
                            long lastSaveTime)
                     throws java.lang.Exception
        Description copied from class: AbstractSessionDataStore
        Store the session data persistently.
        Specified by:
        doStore in class AbstractSessionDataStore
        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
      • ensureIndexes

        protected void ensureIndexes()
                              throws com.mongodb.MongoException
        Throws:
        com.mongodb.MongoException
      • isPassivating

        @ManagedAttribute(value="does store serialize sessions",
                          readonly=true)
        public boolean isPassivating()
        Description copied from interface: SessionDataStore
        True if this type of datastore will passivate session objects
        Returns:
        true if this store can passivate sessions, false otherwise