Coverage Report

Coverage Report - pt.digitalis.dif.controller.security.managers.impl.SessionGarbageCollector

Classes in this File

0/20

0/14

 /**
  * 2007, Digitalis Informatica. All rights reserved. Distribuicao e Gestao de Informatica, Lda. Estrada de Paco de Arcos
  * num.9 - Piso -1 2780-666 Paco de Arcos Telefone: (351) 21 4408990 Fax: (351) 21 4408999 http://www.digitalis.pt
  */
 package pt.digitalis.dif.controller.security.managers.impl;
 
 import java.util.ConcurrentModificationException;
 import java.util.HashMap;
 import java.util.Map;
 
 import pt.digitalis.dif.controller.interfaces.IPrivateDIFSession;
 import pt.digitalis.dif.startup.DIFGeneralConfigurationParameters;
 import pt.digitalis.dif.utils.logging.DIFLogger;
 
 /**
  * Monitor thread that collects inactive sessions and discards them
  * 
  * @author Pedro Viegas <a href="mailto:pviegas@digitalis.pt">pviegas@digitalis.pt</a>
  * @author Rodrigo Gonçalves <a href="mailto:rgoncalves@digitalis.pt">rgoncalves@digitalis.pt</a>
  * @created Dec 11, 2007
  */
 public class SessionGarbageCollector extends Thread {
 
     /** The time interval in seconds for each inactive session cleanup */
     private final int cleanUpInterval;
 
     /** The session manager to monitor */
     private final SessionManagerImpl sessionManager;
 
     /**
      * @param sessionManager
      */
     public SessionGarbageCollector(SessionManagerImpl sessionManager)
     {
         this.sessionManager = sessionManager;
         this.cleanUpInterval = DIFGeneralConfigurationParameters.getInstance().getSecondsForSessionCleanup();
     }
 
     /**
      * @see java.lang.Thread#run()
      */
     @Override
     public void run()
     {
 
         while (true)
         {
             try
             {
                 synchronized (this)
                 {
                     wait(cleanUpInterval * 1000);
                 }
             }
             catch (InterruptedException e)
             {
             }
 
             try
             {
                 Map<String, IPrivateDIFSession> loggedSessions = new HashMap<String, IPrivateDIFSession>();
                 loggedSessions.putAll(sessionManager.getLoggedSessions());
 
                 synchronized (sessionManager)
                 {
 
                     // Prevent NPE if there are no logged sessions
                     if (loggedSessions != null && loggedSessions.values().size() > 0)
                     {
                         synchronized (loggedSessions)
                         {
                             for (IPrivateDIFSession session: loggedSessions.values())
                                 if (session.isMarkedForRemoval() || session.hasExpiredAfterTimeOut())
                                     sessionManager.removeSession(session.getSessionID());
                         }
                     }
                 }
             }
             catch (ConcurrentModificationException e)
             {
                 DIFLogger.getLogger().error(
                         "Could not purge DIF Sessions. Concurent access detected. Will purge on next cycle.");
             }
         }
     }
 }

1	0	/**
2		* 2007, Digitalis Informatica. All rights reserved. Distribuicao e Gestao de Informatica, Lda. Estrada de Paco de Arcos
3		* num.9 - Piso -1 2780-666 Paco de Arcos Telefone: (351) 21 4408990 Fax: (351) 21 4408999 http://www.digitalis.pt
4		*/
5		package pt.digitalis.dif.controller.security.managers.impl;
6
7		import java.util.ConcurrentModificationException;
8		import java.util.HashMap;
9		import java.util.Map;
10
11		import pt.digitalis.dif.controller.interfaces.IPrivateDIFSession;
12		import pt.digitalis.dif.startup.DIFGeneralConfigurationParameters;
13		import pt.digitalis.dif.utils.logging.DIFLogger;
14
15		/**
16		* Monitor thread that collects inactive sessions and discards them
17		*
18		* @author Pedro Viegas <a href="mailto:pviegas@digitalis.pt">pviegas@digitalis.pt</a>
19		* @author Rodrigo Gonçalves <a href="mailto:rgoncalves@digitalis.pt">rgoncalves@digitalis.pt</a>
20		* @created Dec 11, 2007
21		*/
22		public class SessionGarbageCollector extends Thread {
23
24		/** The time interval in seconds for each inactive session cleanup */
25		private final int cleanUpInterval;
26
27		/** The session manager to monitor */
28		private final SessionManagerImpl sessionManager;
29
30		/**
31		* @param sessionManager
32		*/
33	0	public SessionGarbageCollector(SessionManagerImpl sessionManager)
34		{
35	0	this.sessionManager = sessionManager;
36	0	this.cleanUpInterval = DIFGeneralConfigurationParameters.getInstance().getSecondsForSessionCleanup();
37	0	}
38
39		/**
40		* @see java.lang.Thread#run()
41		*/
42		@Override
43		public void run()
44		{
45
46	0	while (true)
47		{
48		try
49		{
50	0	synchronized (this)
51		{
52	0	wait(cleanUpInterval * 1000);
53		}
54		}
55	0	catch (InterruptedException e)
56		{
57		}
58
59		try
60		{
61	0	Map<String, IPrivateDIFSession> loggedSessions = new HashMap<String, IPrivateDIFSession>();
62	0	loggedSessions.putAll(sessionManager.getLoggedSessions());
63
64	0	synchronized (sessionManager)
65		{
66
67		// Prevent NPE if there are no logged sessions
68	0	if (loggedSessions != null && loggedSessions.values().size() > 0)
69		{
70	0	synchronized (loggedSessions)
71		{
72	0	for (IPrivateDIFSession session: loggedSessions.values())
73	0	if (session.isMarkedForRemoval() \|\| session.hasExpiredAfterTimeOut())
74	0	sessionManager.removeSession(session.getSessionID());
75		}
76		}
77		}
78		}
79	0	catch (ConcurrentModificationException e)
80		{
81	0	DIFLogger.getLogger().error(
82	0	"Could not purge DIF Sessions. Concurent access detected. Will purge on next cycle.");
83		}
84		}
85		}
86		}