/**
    * 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.");
              }
          }
      }
  }