Jetty example source code file (AbstractStore.java)

This example Jetty source code file (AbstractStore.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Jetty tags/keywords

abstractstore, abstractstore, exception, exception, http, logger, manager, object, request, response, scavenger, scavenger, servlet, store, store, string, timer, timertask, util

The Jetty AbstractStore.java source code

// ========================================================================
// $Id: AbstractStore.java,v 1.5 2004/06/22 16:23:44 jules_gosnell Exp $
// Copyright 2002-2004 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at 
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ========================================================================

package org.mortbay.j2ee.session;

//----------------------------------------

import java.util.Timer;
import java.util.TimerTask;

import javax.servlet.http.HttpServletRequest;

import org.jboss.logging.Logger;

//----------------------------------------

public abstract class AbstractStore implements Store
{
    protected final static Logger _log = Logger.getLogger(AbstractStore.class);

    // distributed scavenging

    /**
     * The period between scavenges
     */
    protected int _scavengerPeriod = 60 * 30; // 1/2 an hour

    public int getScavengerPeriod()
    {
        return _scavengerPeriod;
    }

    public void setScavengerPeriod(int secs)
    {
        _scavengerPeriod = secs;
    }

    /**
     * The extra time we wait before tidying up a CMPState to ensure that if it
     * loaded locally it will be scavenged locally first...
     */
    protected int _scavengerExtraTime = 60 * 30; // 1/2 an hour

    public int getScavengerExtraTime()
    {
        return _scavengerExtraTime;
    }

    public void setScavengerExtraTime(int secs)
    {
        _scavengerExtraTime = secs;
    }

    /**
     * A maxInactiveInterval of -1 means never scavenge. The DB would fill up
     * very quickly - so we can override -1 with a real value here.
     */
    protected int _actualMaxInactiveInterval = 60 * 60 * 24 * 28; // 28 days

    public int getActualMaxInactiveInterval()
    {
        return _actualMaxInactiveInterval;
    }

    public void setActualMaxInactiveInterval(int secs)
    {
        _actualMaxInactiveInterval = secs;
    }

    public Object clone()
    {
        try
        {
            AbstractStore as = (AbstractStore) (getClass().newInstance());
            as.setScavengerPeriod(_scavengerPeriod);
            as.setScavengerExtraTime(_scavengerExtraTime);
            as.setActualMaxInactiveInterval(_actualMaxInactiveInterval);
            return as;
        }
        catch (Exception e)
        {
            _log.warn("could not clone Store", e);
            return null;
        }
    }

    protected Manager _manager;

    public Manager getManager()
    {
        return _manager;
    }

    public void setManager(Manager manager)
    {
        _manager = manager;
    }

    protected Timer _scavenger;

    // Store LifeCycle
    public void start() throws Exception
    {
        _log.trace("starting...");
        boolean isDaemon = true;
        _scavenger = new Timer(isDaemon);
        long delay = _scavengerPeriod
                + Math.round(Math.random() * _scavengerPeriod);
        if (_log.isDebugEnabled())
            _log.debug("starting distributed scavenger thread...(period: "
                    + delay + " secs)");
        _scavenger.scheduleAtFixedRate(new Scavenger(), delay * 1000,
                _scavengerPeriod * 1000);
        _log.debug("...distributed scavenger thread started");
        _log.trace("...started");
    }

    public void stop()
    {
        _log.trace("stopping...");
        _log.debug("stopping distributed scavenger thread...");
        _scavenger.cancel();
        _scavenger = null;
        _log.debug("...distributed scavenger thread stopped");

        try
        {
            scavenge();
        }
        catch (Exception e)
        {
            _log.warn("error scavenging distributed sessions", e);
        }

        _log.trace("...stopped");
    }

    public void destroy()
    {
        _log.trace("destroying...");
        _log.trace("...destroyed");
    }

    class Scavenger extends TimerTask
    {
        public void run()
        {
            try
            {
                scavenge();
            }
            catch (Throwable e)
            {
                _log.warn("could not scavenge distributed sessions", e);
            }
        }
    }

    // ID allocation

    public String allocateId(HttpServletRequest request)
    {
        return getManager().getIdGenerator().nextId(request);
    }

    public void deallocateId(String id)
    {
        // these ids are disposable
    }

    // still abstract...

    //   // Store LifeCycle
    //   void destroy();	// corresponds to ctor
    //
    //   boolean isDistributed();
    //
    //   // State LifeCycle
    //   State newState(String id, int maxInactiveInterval) throws Exception;
    //   State loadState(String id) throws Exception;
    //   void  storeState(State state) throws Exception;
    //   void  removeState(State state) throws Exception;
    //
    //   // Store misc
    //   void scavenge() throws Exception;
    //   void passivateSession(StateAdaptor sa);
}