InternalSession.java revision 7b3fa0c4c626865e92012ef9f885e91d945850ea
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 2005 Sun Microsystems Inc. All Rights Reserved
*
* The contents of this file are subject to the terms
* of the Common Development and Distribution License
* (the License). You may not use this file except in
* compliance with the License.
*
* You can obtain a copy of the License at
* See the License for the specific language governing
* permission and limitations under the License.
*
* When distributing Covered Code, include this CDDL
* Header Notice in each file and include the License file
* at opensso/legal/CDDLv1.0.txt.
* If applicable, add the following below the CDDL Header,
* with the fields enclosed by brackets [] replaced by
* your own identifying information:
* "Portions Copyrighted [year] [name of copyright owner]"
*
* $Id: InternalSession.java,v 1.21 2009/03/20 21:05:25 weisun2 Exp $
*
* Portions Copyrighted 2011-2016 ForgeRock AS.
*/
/**
* The <code>InternalSession</code> class represents a Webtop internal session.
* <p>
* A session has four states: invalid, valid, inactive, and destroyed. The initial state of a session is invalid.
*
* @see SessionState
*
*/
/*
* Logging message
*/
/*
* Session property names
*/
/*
* Support objects (do not serialize)
*/
private transient SessionService sessionService;
private transient SessionServiceConfig serviceConfig;
private transient SessionLogging sessionLogging;
private transient SessionAuditor sessionAuditor;
/*
* System properties
*/
private static boolean isEnableHostLookUp = SystemProperties.getAsBoolean(Constants.ENABLE_HOST_LOOKUP);
/* This is the maximum extra time for which the timed out sessions lives in the session server */
@JsonProperty("purgeDelay")
/* Maximum frequency with which the access time in the repository will be updated. */
/* default idle time for invalid sessions */
@JsonProperty("maxDefaultIdleTime")
private static final long maxDefaultIdleTimeInMinutes =
/*
* State
*/
private String clientDomain;
private boolean willExpireFlag;
private boolean isSessionUpgrade = false;
private transient AuthContextLocal authContext;
private transient LoginContext loginContext;
private transient SessionPersistenceManager persistenceManager;
@JsonProperty("creationTime")
private long creationTimeInSeconds;
@JsonProperty("latestAccessTime")
private long latestAccessTimeInSeconds;
@JsonProperty("maxSessionTime")
private long maxSessionTimeInMinutes;
@JsonProperty("maxIdleTime")
private long maxIdleTimeInMinutes;
@JsonProperty("maxCachingTime")
private long maxCachingTimeInMinutes;
@JsonProperty("timedOutAt")
private final ConcurrentMap<SessionID, TokenRestriction> restrictedTokensBySid = new ConcurrentHashMap<>();
new ConcurrentHashMap<>();
/*
* The URL map for session events of THIS session only : SESSION_CREATION, IDLE_TIMEOUT, MAX_TIMEOUT, LOGOUT,
* REACTIVATION, DESTROY. Each URL in the map is associated with a set of token ids (master and potentially all of
* the restricted token ids associated with the master) that will be used in notification
*/
@JsonIgnore private boolean isISStored = false;
private volatile boolean reschedulePossible;
/* Session handle is used to prevent administrator from impersonating other users. */
/**
* Creates an instance of the Internal Session with its key dependencies exposed.
*
* Note: This InternalSession will be in an invalid state.
*
* @param sid Non null Session ID.
* @param service Non null SessionService.
* @param debug Debugging instance to use for all logging.
*/
sessionProperties = new Properties();
willExpireFlag = true;
}
/**
* Creates a new InternalSession with the given Session ID.
*
* Note: This InternalSession will be in an invalid state.
*
* @param sid SessionID Non null Session ID.
*/
this(sid,
}
/**
* Default constructor required for deserialisation, and should not be used elsewhere.
*
* This constructor is intentionally blank, except for setting isISStored to true (if the InternalSession is being
* deserialised, it is being loaded from storage).
* When deserialised the code responsible for instantiating it will have no means of resolving dependencies.
*
* Instead this is deferred to
* {@link com.iplanet.dpro.session.service.InternalSession#setSessionServiceDependencies(
* SessionService, SessionServiceConfig, SessionLogging, SessionAuditor, com.sun.identity.shared.debug.Debug)}
*/
public InternalSession() {
isISStored = true;
}
/**
* The debug instance is not restored during deserialisation.
* @param debug Non null debug instance.
*/
}
/**
* The SessionService is not restored during deserialisation.
* @param service Non null SessionService.
*/
public void setSessionServiceDependencies(SessionService service, SessionServiceConfig serviceConfig,
this.sessionService = service;
this.serviceConfig = serviceConfig;
this.sessionLogging = sessionLogging;
this.sessionAuditor = sessionAuditor;
}
/**
* Schedule this task to TimerPool according to the current state.
*/
protected void reschedule() {
}
public void cancel() {
}
/**
* Returns the SessionID of this Internal Session.
* @return SessionID for the internal session object
*/
return sessionID;
}
/**
* Returns the type of Internal Session.
* @return <code>USER</code> or <code>APPLICATION</code>.
*/
public SessionType getType() {
return sessionType;
}
/**
* Set the type of Internal Session. User OR Application.
*
* @param type <code>USER</code> or <code>APPLICATION</code>.
*/
sessionType = type;
}
/**
* Returns Client ID, accessing this Internal Session.
*
* @return Client ID.
*/
public String getClientID() {
return clientID;
}
/**
* Sets Client ID for this Internal Session.
*
* @param id
*/
}
/**
* Returns the Domain of the Client
*
* @return Client Domain
*/
public String getClientDomain() {
return clientDomain;
}
/**
* Sets the Clieant's Domain.
*
* @param domain
* Client Domain
*/
}
/**
* Returns maximum time allowed for the Internal Session.
* @return the number of maximum minutes for the session
*/
public long getMaxSessionTime() {
return maxSessionTimeInMinutes;
}
/**
* Sets the maximum time(in minutes) allowed for the Internal Session
*
* @param t
* Maximum Session Time
*/
public void setMaxSessionTime(long t) {
boolean mayReschedule = false;
if (t < maxSessionTimeInMinutes) {
mayReschedule = true;
}
reschedule();
}
}
/**
* Returns the maximum idle time(in minutes) for the Internal Session.
* @return the number maximum idle minutes
*/
public long getMaxIdleTime() {
return maxIdleTimeInMinutes;
}
/**
* Sets the maximum idle time(in minutes) for the Internal Session.
*
* @param t
*/
public void setMaxIdleTime(long t) {
boolean mayReschedule = false;
if (t < maxIdleTimeInMinutes) {
mayReschedule = true;
}
maxIdleTimeInMinutes = t;
reschedule();
}
}
/**
* Returns the maximum caching time(in minutes) allowed for the Internal
* Session.
* @return Maximum Cache Time
*/
public long getMaxCachingTime() {
return maxCachingTimeInMinutes;
}
/**
* Sets the maximum caching time(in minutes) for the Internal Session.
*
* @param t
* Maximum Caching Time
*/
public void setMaxCachingTime(long t) {
}
/**
* Returns the time(in seconds) for which the Internal Session has not been
* accessed.
* @return session idle time
*/
public long getIdleTime() {
}
/**
* Returns the total time left(in seconds) for the Internal Session. Returns 0 if the time left is negative.
* @return Time left for the internal session to be invalid
*/
public long getTimeLeft() {
}
/**
* Returns the extra time left(in seconds) for the Internal Session after
* the session timed out.
* @return time remaining before purge. <code> -1 </code> if the session
*/
public long getTimeLeftBeforePurge() {
/*
* period.
*/
if (!isTimedOut()) {
return -1;
}
/*
* Return the extra time left (in seconds), if the session has timed out due to
*/
}
/**
* @return <code>true</code> if the Internal session has timedout ,
* <code>false</code> otherwise
*/
public boolean isTimedOut() {
return timedOutTimeInSeconds != 0;
}
/**
* Cache the cookie string. No guarantees are made as to its continued persistence.
* @param cookieString The cookie string to persist.
*/
this.cookieStr = cookieString;
}
/**
* Returns the cached cookie string for this InternalSession. May be null.
* @return The cached cookie string. May be null.
*/
public String getCachedCookieString() {
return cookieStr;
}
/**
* Return the SessionID object which represents this InternalSession.
* @return The session ID.
*/
public SessionID getSessionID() {
return sessionID;
}
/**
* Returns the state of the Internal Session
* @return the session state can be VALID, INVALID, INACTIVE or DESTROYED
*/
public SessionState getState() {
return sessionState;
}
/**
* Get the authentication context associated with this session.
*
* @return the AuthContextLocal associated with this session
*/
public AuthContextLocal getAuthContext() {
return authContext;
}
/**
* Gets whether this session has an associated authenticationContext.
* @return true if this session has an authentication context.
*/
public boolean hasAuthenticationContext() {
return null != authContext;
}
/**
* Sets the authentication context.
*
* @param authContext the authentication context
*/
this.authContext = authContext;
}
/**
* Clears the authentication context from this session.
*/
public void clearAuthContext() {
this.authContext = null;
}
/**
* Gets the login context from this session.
* @return the login context
*/
public LoginContext getLoginContext() {
return loginContext;
}
/**
* Sets the login context associated with this session.
* @param loginContext a LoginContext to associate with this session.
*/
this.loginContext = loginContext;
}
/**
* Returns the value of the specified key from the Internal Session property
* table.
*
* @param key
* Property key
* @return string value for the key from Internal Session table.
*/
}
/**
* Returns the Enumeration of property names of the Internal Session
* property table.
* @return list of properties in the Internal session table.
*/
public Enumeration getPropertyNames() {
return sessionProperties.propertyNames();
}
/**
* Helper method to check if a property is protected or not.
*
* We introduce a mechanism to protect certain "core" or "internal"
* properties from updates via remote SetProperty method of the
* SessionService. Allowing remote self-updates to session properties leads
* to a security vulnerability which allows unconstrained user impersonation
* or privilege elevation. See bug # 4814922 for more information
*
* protectedProperties contains a set of property names which can not be
* remotely updated. It is initially populated using static initializer. We
* also implemented an extra safety mechanism intended to protect from
* accidental reopening of this security hole in the future if a property
* name changes or new property is introduced without corresponding update
* of the static hardcoded list of protected properties below. This
* mechanism automatically adds any property to protectedProperties if it is
* set via local invocation of putProperty.
*
* However, some properties (such as Locale and CharSet) must be settable
* both locally and remotely. In order to make it configurable we use a
* second table called remotelyUpdateableProperties. Note that
* protectedProperties takes precedence over remotelyUpdateableProperties:
* remotelyUpdateableProperties will be consulted only if a property is not
* on the protectedProperties list already.
*
* The following tables defines the behavior of putProperty() and
* putExternalProperty() depending on whether property name is present in
* protectedProperties or remotelyUpdateableProperty list
*
* protectedProperties remotelyUpdateableProperties putProperty()
* putExternalProperty()
*
* in n/a sets value logs, does nothing
*
* out in sets value sets value
*
* out out sets value and sets value adds to protectedProperty
*
* @param key
* property name.
* @return true if property is protected else false.
*/
return true;
}
return false;
}
if (protectedPropertiesConfig != null) {
",");
while (st.hasMoreTokens()) {
if (sessionDebug.messageEnabled()) {
}
}
}
return protectedProperties;
}
/**
* Sets the key-value pair in the InternalSession property table if it is
* not protected. If it is protected client should have permission to set
* it. This method is to be used in conjuction with
* SessionRequestHandler/SessionService invocation path If the property is
* protected, an attempt to remotely set a protected property is logged and
* the method throws an Exception. Otherwise invocation is delegated to
* internalPutProperty()
*
* Note that package default access is being used
*
* @param clientToken
* Token of the client setting external property.
* @param key
* Property key
* @param value
* Property value for the key
* @exception SessionException is thrown if the key is protected property.
*
*/
throws SessionException {
try {
} catch (SessionException se) {
throw se;
}
if (debug.messageEnabled()) {
+ " after validating client identity and permissions");
}
}
/**
* Sets the key-value pair in the Internal Session property table. This
* method should only be invoked locally by code running in the same server
* VM. Remote invocations should use putExternalProperty(). This is a simple
* wrapper around internalPutProperty(), which in addition calls to
* registerProtectedProperty() to make sure that if a property key is not
* already on the list of protected properties, it will be automatically
* added there (unless it is also on remotelyUpdateableProperties list!)
*
* @param key
* Property key
* @param value
* Property value for the key
*/
}
/**
* Sets the key-value pair in the Internal Session property table.
*
* @param key
* Property key
* @param value
* Property value for the key
*/
return;
}
if (isEnableHostLookUp) {
try {
} catch (UnknownHostException uhe) {
"InternalSession.internalputProperty():"
+ "Unable to get HostName for:" + value
+ " SessionException: ", uhe);
}
} else {
}
} else {
}
}
}
/**
* Sets the status of the isSessionUpgrade flag to which determines if the
* <code>Session</code> is in the upgrade state or not.
*
* @param value <code>true</code> if it is an upgrade
* <code>false</code> otherwise
*/
public void setIsSessionUpgrade(boolean value) {
}
/**
* Gets the status of the <code>Session</code> if is an upgrade state
*
* @return <code>true</code> if the session is in upgrade state
* <code>false</code> otherwise
*/
public boolean getIsSessionUpgrade() {
return isSessionUpgrade;
}
/**
* Set whether this InternalSession is persisted.
* @param isStored True if the session is persisted, false otherwise.
*/
}
/**
* Returns whether the InternalSession represented has been stored. If this is true, changes to this object will
* update the stored version.
* return <code>true</code> if the internal session is stored
* <code>false</code> otherwise
*/
public boolean isStored() {
return isISStored;
}
/**
* Changes the state of the session to ACTIVE after creation.
* @param userDN
* @return <code> true </code> if the session is successfully activated
* after creation , <code>false</code> otherwise
*/
}
/**
* Changes the state of the session to ACTIVE after creation.
* @param userDN
* @param stateless Indicates that the log in session is a stateless session.
* @return <code> true </code> if the session is successfully activated
* after creation , <code>false</code> otherwise
*/
return false;
}
// Exceeded max active sessions, but allow if the user is super-admin
return false;
}
// checking Session Quota Constraints
if (SessionConstraint.checkQuotaAndPerformAction(this)) {
if (debug.messageEnabled()) {
}
return false;
}
}
if (reschedulePossible && !stateless) {
reschedule();
}
}
return true;
}
/*
* The session quota checking will be bypassed if:
* (1) the login user is the super user (not including users assigned the top level admin role), or
* (2) the token is an application token (e.g. Agent)
*/
private boolean shouldIgnoreSessionQuotaChecking() {
boolean ignore = false;
ignore = true;
}
return ignore;
}
/**
* Gets the User Universal ID
* @return UUID
*/
return getProperty(UNIVERSAL_IDENTIFIER);
}
/**
* Changes the state of the session to ACTIVE from IN-ACTIVE.
*/
public void reactivate() {
reschedule();
}
/**
* Sets the willExpireFlag. This flag specify that whether the session will
* ever expire or not.
*/
public void setNonExpiring() {
cancel();
willExpireFlag = false;
}
/**
* Checks the invalid session idle time. If this session is invalid and idle
* for more than 3 minutes, we will need to remove it from the session table
*
* @return <code>true</code> if the max default idle time expires
*/
private boolean checkInvalidSessionDefaultIdleTime() {
long timeLeftInSeconds = creationTimeInSeconds + MINUTES.toSeconds(maxDefaultIdleTimeInMinutes) - currentTimeInSeconds;
return timeLeftInSeconds < 0;
}
/**
* Checks whether the session should change state and returns the state that the session should be in.
*/
public StateTransition checkSessionUpdate() {
if (!willExpireFlag) {
return StateTransition.NO_CHANGE;
}
if (!isTimedOut()) {
if (isInvalid()) {
if (checkInvalidSessionDefaultIdleTime()) {
return StateTransition.DESTROY;
} else {
return StateTransition.NO_CHANGE;
}
}
if (getTimeLeft() == 0) {
return StateTransition.MAX_TIMEOUT;
}
if (getIdleTime() >= MINUTES.toSeconds(maxIdleTimeInMinutes) && sessionState != SessionState.INACTIVE) {
return StateTransition.IDLE_TIMEOUT;
}
return StateTransition.NO_CHANGE;
} else {
// do something special for the timed out sessions
if (getTimeLeftBeforePurge() <= 0) {
return StateTransition.PURGE;
} else {
return StateTransition.NO_CHANGE;
}
}
}
/**
* Changes the state of the session and sends Session Notification when
* session times out.
*
* TODO: This logic should be moved into LocalOperations once InternalSessionTaskRunnable is removed.
*
*/
public void changeStateAndNotify(int eventType) {
if (purgeDelayInSeconds == 0) {
return;
}
}
trimSession();
}
}
/**
* Changes the state of the session. Does not notify SessionService, or anything else using Session Notification.
*/
this.sessionState = state;
}
public SessionInfo toSessionInfo() {
return toSessionInfo(true);
}
/**
* Transfers the info about the Internal Session to Session Info.
* @return SessionInfo
*/
if (withIds) {
} else {
}
}
if (willExpireFlag) {
} else {
// Sessions such as authentication session will never be destroyed
info.setNeverExpiring(true);
}
//Adding the sessionHandle as a session property, so the sessionHandle is available in Session objects.
}
return info;
}
/**
* Sets the last time the client sent a request associated with this
* session, as the number of seconds since midnight January 1, 1970 GMT.
*
* Once updated the Session will be persisted.
*/
public void setLatestAccessTime() {
}
}
/**
* Sets the state of the Internal Session.
*
* @param state
*/
}
/**
* Returns the URL of the Session events and the associated master and
* restricted token ids.
* @return Map of session event URLs and their associated SessionIDs.
*/
Map<String, Set<SessionID>> getSessionEventURLs(int eventType, SessionBroadcastMode logoutDestroyBroadcast) {
try {
} else {
}
}
}
}
} catch (Exception e) {
}
}
if (sessionIDs != null) {
} else {
}
}
return urls;
}
/**
* Adds a listener for the associated session ID.
* @param url The listening URL.
* @param sid The associated SessionID.
*/
if (previousValue != null) {
}
}
}
}
/**
* This setter method is used by the JSON serialization mechanism and should not be used for other purposes.
*
* @param restrictedTokensBySid The deserialized map of sid<->restricted tokens that should be stored in a
* ConcurrentHashMap.
*/
private void setRestrictedTokensBySid(ConcurrentMap<SessionID, TokenRestriction> restrictedTokensBySid) {
}
}
/**
* This setter method is used by the JSON serialization mechanism and should not be used for other purposes.
*
* @param sessionEventURLs The deserialized map of sessionEventURLs that should be stored in a ConcurrentHashMap.
*/
}
}
/**
* Returns the value of willExpireFlag.
*
*/
public boolean willExpire() {
return willExpireFlag;
}
/**
* Determine whether it is an application session.
*
* @return <code>true</code> if this is an application session, <code>false</code> otherwise.
*/
boolean isAppSession() {
}
/**
* Sets the creation time of the Internal Session, as the number of seconds
* since midnight January 1, 1970 GMT.
*/
private void setCreationTime() {
}
/**
* Add new restricted token pointing at the same session to the list.
*
* @param sid The session ID.
* @param restriction The token restriction.
* @return The existing session ID instance if this TokenRestriction was already mapped to a session ID,
* <code>null</code> otherwise.
*/
if (previousValue == null) {
return null;
}
return previousValue;
}
/**
* Returns the TokenRestriction for the given SessionID.
*
* @param sid Possibly null SessionID.
* @return Null indicates there is no restriction on the Session.
*/
}
}
}
/**
* Returns true if cookies are supported.
*
* @return true if cookie supported;
*/
public boolean getCookieSupport() {
boolean cookieSupport = false;
} else if (this.cookieMode != null) {
cookieSupport = this.cookieMode;
}
if (debug.messageEnabled()) {
}
return cookieSupport;
}
/**
* In case of session timeout the session is trimmed to reduce the memory
* overhead. Even if the session lives in the server for the extra time out
* period, the memory is not abused. Instance variables preserved are, 1)
* sessionID 2) timedOutAt 3) clientID 4) purgeDelayInSeconds 5)
* sessionProperties(loginURL/SessionTimedOut/AM_CTX_ID/SAML2IDPSessionIndex)
* 6) sessionEventURLs 7) sessionState All other instance variables are
* cleaned to save memory.
*/
private void trimSession() {
clientDomain = null;
// Clean Session Properties
if (sessionTimedOut != null)
}
if (idpSessionIndex != null) {
}
}
/**
* set the cookieMode based on whether the request has cookies or not. This
* method is called from createSSOToken(request) method in SSOTokenManager.
*
* @param cookieMode ,
* Boolean value whether request has cookies or not.
*/
if (cookieMode != null) {
this.cookieMode = cookieMode;
}
}
/**
* Used during session deserialization. This method SHALL NOT be invoked by custom code.
*
* @param sessionHandle The sessionHandle to set.
*/
this.sessionHandle = sessionHandle;
//No need to update the session for failover, as this method is invoked only upon session
}
/**
* Returns the session handle.
*
* @return The session handle.
*/
public String getSessionHandle() {
return sessionHandle;
}
/**
* Computes session object expiration time as the smallest of the remaining idle time (or purge delay if the
* session has already timed out) or the session lifetime limit.
* <p>
* Time value is returned in the requested unit (accurate to millisecond) and uses the
* same epoch as {@link System#currentTimeMillis()}.
*
* @param timeUnit the time unit to return the result in.
* @return the result in the given units.
*/
if (timeLeftInSeconds == 0) {
}
}
/**
* Returns time at which session's lifetime expires.
* <p>
* Time value is returned in the requested unit (accurate to millisecond) and uses the
* same epoch as {@link System#currentTimeMillis()}.
*
* @see #getMaxSessionTime()
* @param timeUnit the time unit to return the result in.
* @return the result in the given units.
*/
return timeUnit.convert(creationTimeInSeconds + MINUTES.toSeconds(maxSessionTimeInMinutes), SECONDS);
}
/**
* Returns time at which session's idle time expires.
* <p>
* Time value is returned in the requested unit (accurate to millisecond) and uses the
* same epoch as {@link System#currentTimeMillis()}.
*
* @see #getMaxIdleTime()
* @param timeUnit the time unit to return the result in.
* @return the result in the given units.
*/
return timeUnit.convert(latestAccessTimeInSeconds + MINUTES.toSeconds(maxIdleTimeInMinutes), SECONDS);
}
/**
* If the session has timed out, returns time at which session's purge delay expires.
* <p>
* Time value is returned in the requested unit (accurate to millisecond) and uses the
* same epoch as {@link System#currentTimeMillis()}.
*
* @param timeUnit the time unit to return the result in.
* @return the result in the given units.
*/
if (!isTimedOut()) {
return -1;
}
}
/**
* Correctly read and reschedule this session when it is read.
*/
public void scheduleExpiry() {
if (willExpireFlag) {
}
}
/**
* @return True if the Session has reached an invalid state.
*/
public boolean isInvalid() {
}
/**
* Signals the Session for removal.
*/
private void removeSession() {
}
static void setPurgeDelayInSeconds(long newPurgeDelay) {
}
/**
* Sets the time at which this session timed out due to idle/max timeout. The time is in seconds since the same
* epoch as {@link System#currentTimeMillis()}. A value of 0 indicates that the session has not timed out.
*
* @param timedOutAt the time in seconds at which the session timed out.
*/
void setTimedOutAt(long timedOutAt) {
this.timedOutTimeInSeconds = timedOutAt;
}
}
private void notifyPersistenceManager() {
if (persistenceManager != null) {
}
}
private class InternalSessionTaskRunnable extends GeneralTaskRunnable {
public InternalSessionTaskRunnable() {
}
return false;
}
return false;
}
public boolean isEmpty() {
return true;
}
/**
* @return -1 since it is not a periodic task.
*/
public long getRunPeriod() {
return -1;
}
public void run() {
if (isTimedOut() || isInvalid()) {
return;
}
long timeLeftInSeconds = getTimeLeft();
if (timeLeftInSeconds == 0) {
} else {
} else {
}
}
}
}
if (purgeDelayInSeconds > 0) {
}
}
}
/**
* Schedule this task to TimerPool according to the current state.
*/
private void reschedule() {
switch (sessionState) {
case INVALID:
break;
case VALID:
break;
}
if (timeoutInMillis < scheduledExecutionTime()) {
cancel();
}
if (scheduledExecutionTime() == -1) {
}
}
}
/**
* Correctly read and reschedule this session when it is read.
*/
private void scheduleExpiry() {
if (!isTimedOut()) {
if (isInvalid()) {
// creationTime + maxDefaultIdleTime looks like a suspicious combination
}
} else {
}
} else {
long timeLeftInSeconds = getTimeLeft();
if (timeLeftInSeconds == 0) {
}
} else {
}
} else {
}
}
}
}
} else {
if (expectedTimeInMillis > currentTimeMillis()) {
}
} else {
}
}
}
private void setNonExpiring() {
}
}
/**
* Simple enumeration to report how the session is changing in state
*/
public enum StateTransition {
}
}