gigasessionidmanager.java

是离开的肌肤了卡机是离开的就富利卡及是了的开发及拉考试及的福利科技阿斯利康的肌肤莱卡及时的离开福建阿斯顿发

// ========================================================================
// Copyright 2008 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.jetty.openspaces;

import java.util.HashSet;
import java.util.Random;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.mortbay.jetty.Handler;
import org.mortbay.jetty.Server;
import org.mortbay.jetty.servlet.AbstractSessionIdManager;
import org.mortbay.jetty.servlet.AbstractSessionManager;
import org.mortbay.jetty.webapp.WebAppContext;
import org.mortbay.log.Log;
import org.openspaces.core.GigaSpace;
import org.openspaces.core.GigaSpaceConfigurer;
import org.openspaces.core.space.UrlSpaceConfigurer;
import org.openspaces.core.space.cache.LocalCacheSpaceConfigurer;

import com.gigaspaces.annotation.pojo.SpaceId;
import com.gigaspaces.annotation.pojo.SpaceRouting;

/**
 * GigaspacesSessionIdManager
 *
 * A Jetty SessionIDManager where the in-use session ids are stored
 * in a data grid "cloud".
 */
public class GigaSessionIdManager extends AbstractSessionIdManager
{
    protected HashSet<Id> _sessionIds = new HashSet<Id>();
    protected long _scavengeIntervalSec = 60 * 10; //10mins - TODO could move back to the SessionManager?
    protected String _spaceUrl;
    protected GigaSpace _space;
    protected long _waitMsec = 5000L; //time in msec to wait on read operations
 
    
    /**
     * Id
     *
     * Class to hold the session id. This is really only needed
     * for gigaspaces so that we can annotate routing information etc.
     */
    public static class Id
    {
        private String _id;
        
        public Id()
        {}
        
        public Id(String id)
        {
            _id=id;
        }
        
        public void setId(String id)
        {
            _id=id;
        }
        
        @SpaceId
        @SpaceRouting
        public String getId()
        {
            return _id;
        }
        
        public boolean equals(Object o)
        {
            if (o == null)
                return false;
            Id targetId = (Id)o;
            
            if (targetId.getId() == _id)
                return true;
            
            if (targetId.getId().equals(_id))
                return true;
            
            return false;
        }
    }
    
    public GigaSessionIdManager(Server server)
    {
       super(server);
    }
    
    public GigaSessionIdManager(Server server, Random random)
    {
       super(server, random);
    }
    
    public void setSpaceUrl (String url)
    {
        _spaceUrl=url;
    }
    
    public String getSpaceUrl ()
    {
        return _spaceUrl;
    }
    
    public void setWaitMs (long msec)
    {
        _waitMsec=msec;
    }
   
    
    public long getWaitMs ()
    {
        return _waitMsec;
    }
    
    public void addSession(HttpSession session)
    {
        if (session == null)
            return;
        
        synchronized (_sessionIds)
        {
            if (session instanceof GigaSessionManager.Session)
            {
                String id = ((GigaSessionManager.Session)session).getClusterId();            
                try
                {
                    Id theId = new Id(id);
                    add(theId);
                    _sessionIds.add(theId);
                    if (Log.isDebugEnabled()) Log.debug("Added id "+id);
                }
                catch (Exception e)
                {
                    Log.warn("Problem storing session id="+id, e);
                }
            }
            else
                throw new IllegalStateException ("Session is not a Gigaspaces session");
        }
    }

    public String getClusterId(String nodeId)
    {
        int dot=nodeId.lastIndexOf('.');
        return (dot>0)?nodeId.substring(0,dot):nodeId;
    }

    public String getNodeId(String clusterId, HttpServletRequest request)
    {
        if (_workerName!=null)
            return clusterId+'.'+_workerName;

        return clusterId;
    }

    public boolean idInUse(String id)
    {
        if (id == null)
            return false;
        
        String clusterId = getClusterId(id);
        Id theId = new Id(clusterId);
        synchronized (_sessionIds)
        {
            if (_sessionIds.contains(theId))
                return true; //optimisation - if this session is one we've been managing, we can check locally
            
            //otherwise, we need to go to the space to check
            try
            {
                return exists(theId);
            }
            catch (Exception e)
            {
                Log.warn("Problem checking inUse for id="+clusterId, e);
                return false;
            }
        }
    }

    public void invalidateAll(String id)
    {
        //take the id out of the list of known sessionids for this node
        removeSession(id);
        
        synchronized (_sessionIds)
        {
            //tell all contexts that may have a session object with this id to
            //get rid of them
            Handler[] contexts = _server.getChildHandlersByClass(WebAppContext.class);
            for (int i=0; contexts!=null && i<contexts.length; i++)
            {
                AbstractSessionManager manager = ((AbstractSessionManager)((WebAppContext)contexts[i]).getSessionHandler().getSessionManager());
                if (manager instanceof GigaSessionManager)
                {
                    ((GigaSessionManager)manager).invalidateSession(id);
                }
            }
        }
    }

    public void removeSession(HttpSession session)
    {
        if (session == null)
            return;
        
        removeSession(((GigaSessionManager.Session)session).getClusterId());
    }
    
    public void removeSession (String id)
    {

        if (id == null)
            return;
        
        synchronized (_sessionIds)
        {  
            if (Log.isDebugEnabled())
                Log.debug("Removing session id="+id);
            try
            {               
                Id theId = new Id(id);
                _sessionIds.remove(theId);
                delete(theId);
            }
            catch (Exception e)
            {
                Log.warn("Problem removing session id="+id, e);
            }
        }
        
    }
    
    
    public void setSpace (GigaSpace space)
    {
        _space=space;
    }
    
    public GigaSpace getSpace ()
    {
        return _space;
    }
    
    /** 
     * Start up the id manager.
     * 
     * @see org.mortbay.jetty.servlet.AbstractSessionIdManager#doStart()
     */
    public void doStart()
    {
        try
        { 
            if (_space==null)
                initSpace();
            super.doStart();
        }
        catch (Exception e)
        {
            Log.warn("Problem initialising session ids", e);
            throw new IllegalStateException (e);
        }
    }
    
    /** 
     * Stop the scavenger.
     * 
     * @see org.mortbay.component.AbstractLifeCycle#doStop()
     */
    public void doStop () 
    throws Exception
    {
        super.doStop();
    }
    
    protected void initSpace ()
    throws Exception
    {
        if (_spaceUrl==null)
            throw new IllegalStateException ("No url for space");
        
        UrlSpaceConfigurer usc = new UrlSpaceConfigurer(_spaceUrl);
        LocalCacheSpaceConfigurer lcsc = new LocalCacheSpaceConfigurer(usc.space()); 
        GigaSpaceConfigurer gigaSpaceConfigurer = new GigaSpaceConfigurer(usc.space());
        _space = gigaSpaceConfigurer.gigaSpace();
    }
    
    protected void add (Id id)
    throws Exception
    {
        _space.write(id);
    }
    
    
    protected void delete (Id id)
    throws Exception
    {
        _space.takeIfExists(id, getWaitMs());
        if (Log.isDebugEnabled()) Log.debug ("Deleted id from space: id="+id);
    }
    
    protected boolean exists (Id id)
    throws Exception
    {
        Id idFromSpace = (Id)_space.readIfExists(id, getWaitMs());
        if (Log.isDebugEnabled()) Log.debug("Id="+id+(idFromSpace==null?"does not exist":"exists"));
        if (idFromSpace==null)
            return false;
        return true;
    }
}