Quadcap Embeddable Server

com/quadcap/http/server22/HSession.java

Go to the documentation of this file.

package com.quadcap.http.server22;

/* Copyright 1998 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;
import javax.servlet.http.HttpSessionContext;

import com.quadcap.util.Debug;

/**
 * This class implements the <code>javax.servlet.http.HttpSession</code> interface.
 *
 * @author Stan Bailes
 */
public class HSession implements HttpSession {
    WebApplication                      app;
    String                              sessionId;
    boolean                             valid           = true;
    long                                creationTime    = new Date().getTime();
    long                                lastAccessTime  = creationTime;
    int                                 maxInactiveInterval;
    Hashtable                           appData         = new Hashtable();
    boolean                             newSession      = true;

    /**
     * Construct a new session object.
     *
     * @param app the server context (session context) owning this session.
     * @param sessionId this session's id.
     */
    public HSession(WebApplication app, String sessionId,
                    int maxInactiveInterval)
    {
        this.app = app;
        this.sessionId = sessionId;
        this.maxInactiveInterval = maxInactiveInterval;
    }
    
    /**
     * Returns the identifier assigned to this session. An HttpSession's 
     * identifier is a unique string that is created and maintained by 
     * HttpSessionContext.
     *
     * @return the identifier assigned to this session
     * @exception IllegalStateException if an attempt is made to access  
     * session data after the session has been invalidated
     */
    public String getId() {
        if (!valid) throw new IllegalStateException("session not valid");
        return sessionId;
    }

    /**
     * Returns the context in which this session is bound. 
     *
     * @return the name of the context in which this session is bound  
     * @exception IllegalStateException if an attempt is made to access 
     * session data after the session has been invalidated
     * @deprecated in 2.2
     */
    public HttpSessionContext getSessionContext() {
        return new HttpSessionContext() {
            public Enumeration getIds() { return new Vector().elements(); }
            public HttpSession getSession(String s) { return null; }
        };
    }

    /**
     * Returns the time at which this session representation was created,
     * in milliseconds since midnight, January 1, 1970 UTC.
     * 
     * @return the time when the session was created
     * @exception IllegalStateException if an attempt is made to access  
     * session data after the session has been invalidated
     */
    public long getCreationTime() {
        if (!valid) throw new IllegalStateException("session not valid");
        return creationTime;
    }

    /**
     * Returns the last time the client sent a request carrying the identifier
     * assigned to the session. Time is expressed
     * as milliseconds since midnight, January 1, 
     * 1970 UTC. 
     * Application level operations, such as getting or setting a value
     * associated with the session, does not affect the access time.
     *
     * <P> This information is particularly useful in session management
     * policies.  For example,
     * <UL>
     * <LI>a session manager could leave all sessions
     * which have not been used in a long time 
     * in a given context.
     * <LI>the sessions can be sorted according to age to optimize some task.
     * </UL>
     *
     * @return the last time the client sent a request carrying the identifier 
     * assigned to the session
     * @exception IllegalStateException if an attempt is made to access 
     * session data after the session has been invalidated
     */
    public long getLastAccessedTime() {
        if (!valid) throw new IllegalStateException("session not valid");
        return lastAccessTime;
    }

    /**
     * Causes this representation of the session to be invalidated and removed 
     * from its context.  
     *
     * @exception IllegalStateException if an attempt is made to access  
     * session data after the session has been invalidated
     */
    public void invalidate() {
        if (!valid) throw new IllegalStateException("session not valid");
        Enumeration e = appData.keys();
        while (e.hasMoreElements()) {
            String key = e.nextElement().toString();
            removeValue(key);
        }
        app.removeSession(this);
        valid = false;
    }

    /**
     * Binds the specified object into the session's application layer data
     * with the given name.  Any existing binding with the same name is
     * replaced.  New (or existing) values that implement the
     * HttpSessionBindingListener interface will call its  
     * valueBound() method.
     *
     * @param name the name to which the data object will be bound.  This
     *          parameter cannot be null.
     * @param value the data object to be bound.
     *          This parameter cannot be null. 
     * @exception IllegalStateException if an attempt is made to access  
     *          session data after the session has been invalidated.
     */
    public void setAttribute(String name, Object value) {
        if (!valid) throw new IllegalStateException("session not valid");
        appData.put(name, value);
        if (value instanceof HttpSessionBindingListener) {
            HttpSessionBindingEvent event =
                new HttpSessionBindingEvent(this, name);
            HttpSessionBindingListener listener =
                (HttpSessionBindingListener)value;
            listener.valueBound(event);
        }
    }

    /** 
     * Returns the object bound to the given name in the session's
     * application layer data.  Returns null if there is no such binding.
     *
     * @param name the name of the binding to find
     * @return the value bound to that name, or null if the binding does
     * not exist.
     * @exception IllegalStateException if an attempt is made to access 
     * HttpSession's session data after it has been invalidated
     */
    public Object getAttribute(String name) {
        if (!valid) throw new IllegalStateException("session not valid");
        return appData.get(name);
    }

    /**
     * Removes the object bound to the given name in the session's
     * application layer data.  Does nothing if there is no object
     * bound to the given name.  The value that implements the
     * HttpSessionBindingListener interface will call its
     * valueUnbound() method.
     *
     * @param name the name of the object to remove
     * @exception IllegalStateException if an attempt is made to access 
     * session data after the session has been invalidated
     */
    public void removeAttribute(String name) {
        if (!valid) throw new IllegalStateException("session not valid");
        Object value = appData.get(name);
        if (value != null) {
            appData.remove(name);
            if (value instanceof HttpSessionBindingListener) {
                HttpSessionBindingEvent event =
                    new HttpSessionBindingEvent(this, name);
                HttpSessionBindingListener listener =
                    (HttpSessionBindingListener)value;
                listener.valueUnbound(event);
            }
        }
    }

    /**
     * Return an enumeration of the names of objects in the session's
     * application layer data.
     *
     * @return an enumeration of names
     */
    public Enumeration getAttributeNames() {
        if (!valid) throw new IllegalStateException("session not valid");
        return appData.keys();
    }
    
    /**
     * Returns an array of the names of all the application layer
     * data objects bound into the session. For example, if you want to delete
     * all of the data objects bound into the session, use this method to 
     * obtain their names. 
     * 
     * @return an array containing the names of all of the application layer 
     * data objects bound into the session
     * @exception IllegalStateException if an attempt is made to access  
     * session data after the session has been invalidated
     * @deprecated
     */
    public String[] getValueNames() {
        if (!valid) throw new IllegalStateException("session not valid");
        String[] names = new String[appData.size()];
        Enumeration e = appData.keys();
        int i = 0;
        while (e.hasMoreElements()) {
            names[i++] = (String)e.nextElement();
        }
        return names;
    }

    /**
     * @deprecated
     */
    public Object getValue(String name) {
        return getAttribute(name);
    }

    /**
     * @deprecated
     */
    public void putValue(String name, Object value) {
        setAttribute(name, value);
    }

    /**
     * @deprecated
     */
    public void removeValue(String name) {
        removeAttribute(name);
    }

    /**
     * A session is considered to be "new" if it has been created by the
     * server, but the client has not yet acknowledged joining the session.
     * For example,
     * if the server supported only cookie-based sessions and the client had 
     * completely disabled the use of cookies, then calls to
     * HttpServletRequest.getSession() would 
     * always return "new" sessions. 
     *
     * @return true if the session has been created by the server but the 
     * client has not yet acknowledged joining the session; false otherwise
     * @exception IllegalStateException if an attempt is made to access  
     * session data after the session has been invalidated
     */
    public boolean isNew() {
        if (!valid) throw new IllegalStateException("session not valid");
        return newSession;
    }

    public int getMaxInactiveInterval() {
        if (!valid) throw new IllegalStateException("session not valid");
        return maxInactiveInterval;
    }
    public void setMaxInactiveInterval(int ivl) {
        if (!valid) throw new IllegalStateException("session not valid");
        this.maxInactiveInterval = ivl;
    }

    /**
     * ---- Package-private implementation -----
     */

    boolean isValid() { return valid; }
    void setNotNew() { newSession = false; }
    void updateLastAccess() { lastAccessTime = new Date().getTime(); }
}