/*
    * Créé le 24 janv. 2005
    */
   
   package atg.metier.dao.jdo;
   
   /**
    * <p>Titre : Pool de connexions aux bases de données en JDO</p>
    * <p>Description : Gestion de pool de connexion</p>
   * <p>Copyright : FERRARI Olivier</p>
   * @author  YSMAL Vincent
   * @version 1.0
   * Ce logiciel est régi par la licence CeCILL soumise au droit français et
   * respectant les principes de diffusion des logiciels libres. Vous pouvez
   * utiliser, modifier et/ou redistribuer ce programme sous les conditions
   * de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
   *  sur le site http://www.cecill.info.
   * 
   * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
   * pris connaissance de la licence CeCILL, et que vous en avez accepté les
   * termes.
   */
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.util.Properties;
  import javax.jdo.JDOHelper;
  import javax.jdo.PersistenceManager;
  import javax.jdo.PersistenceManagerFactory;
  import atg.metier.dao.jdbc.exception.ATGDaoBaseIndisponibleException;
  import atg.service.constante.AtgConstantes;
  import atg.service.log.AtgLogManager;
  import atg.util.service.ATGBasicClass;
  
  /**
   * @author Administrateur
   */
  public class ATGDaoJdoPoolDataSource extends ATGBasicClass
  {
    //***************************************************************************
    //Attributs
    //***************************************************************************
  
    /**
     * Référence du pool par défaut
     */
    public static final String                CSTE_DEFAULT_REFERENCE = "Reference par defaut";
  
    /**
     * Instances uniques (pour une référence donnée) du pool de connections
     */
  
    private static java.util.Hashtable        instances              = new java.util.Hashtable();
  
    
    /**
     * nombre de connections maximum crées sur la base de données
     */
    private static final int                  MAX_CONNECTION         = 10;
  
    /**
     * nombre de connections automatiquement crées au démarrage du pool
     */
    private static final int                  START_CONNECTION       = 1;
  
    /**
     * Delai d'attente pour l'obtention d'une connection, exemple 3000 = 3
     * secondes
     */
    private static final int                  MAX_WAIT               = 3000;
  
    /**
     * delai au dela duquel une connexion est consideree comme perdue, exemple
     * 60000 = 60 secondes
     */
    private static final int                  MAX_CTRL_TIME          = 60000;
  
    /**
     * Attribut de la connexion standard
     */
    /*private String                            DRIVER_NAME            = null;
    private String                            USER_NAME              = null;
    private String                            USER_PWD               = null;
    private String                            DB_NAME                = null;
  */
    /**
     * liste des connections créées mais non utilisées
     */
    private java.util.Vector                  freeConnections        = null;
  
    /**
     * nombre de connections en cours (demandées mais pas encore libérées)
     */
    private int                               checkedOut             = 0;
  
    /**
     * driver permettant d'obtenir une connection
     */
    //protected java.sql.Driver                 driver                 = null;
 
   /**
    * référence du pool de données
    */
   protected String                          reference              = "";
 
   /**
    * ensemble des connections creees sur la base de donnees
    */
   protected java.util.Hashtable             ctrlConnexion          = null;
 
   protected static java.util.logging.Logger logger_                = null;
 
   private PersistenceManagerFactory         pmf                    = null;
 
   /**
    * Ecriture des logs
    */
   protected java.util.logging.Logger getLogger()
   {
     if (logger_ == null)
         logger_ = AtgLogManager
             .getLog(AtgConstantes.ATG_LOG_CATEGORY_METIER_DAO_JDO);
 
     return logger_;
   }
 
   private ATGDaoJdoPoolDataSource(String reference)
   {
     String properties = atg.service.constante.AtgConstantesWF
         .getValue("PATH_JDO_FILE");
 
     Properties props = new Properties();
     String nomFichier = properties + reference + "_JDO.properties";
     try
     {
       props.load(new FileInputStream(nomFichier));
       //props.setProperty("host", "128.96.197.228");
       //logFinest("Connection à la machine : " + "128.96.197.228");
       //props.setProperty("server", "versant");      
       pmf = JDOHelper.getPersistenceManagerFactory(props);
     }
     catch (FileNotFoundException e)
     {
       this
           .logSevere("Immpossible de trouver le fichier de properties pour le serveur JDO : "
               + nomFichier);
     }
     catch (IOException e)
     {
       this.logSevere("Erreur d'entrée/sortie dans le fichier de properties : "
           + nomFichier);
     }
   }
 
   /**
    * Renvoie une connection au serveur de persistance.
    * 
    * @return PersistenceManager Reférence vers le gestionnaire de persistance
    *         Jdo
    */
   public PersistenceManager getPersistenceManager()
       throws ATGDaoBaseIndisponibleException
   {
     try
     {
       PersistenceManager conn = getPersistenceManager(MAX_WAIT);
       return conn;
     }
     catch (ATGDaoBaseIndisponibleException exception)
     {
       // ecriture d'une trace + renvoie de la valeur 'null'
       logSevere("Impossible de fournir une connection correcte : "
           + exception.getCause() + " / " + exception.getMessage());
       throw new ATGDaoBaseIndisponibleException();
     }
   }
 
   /**
    * Renvoie une connection à la base de données. Attend au maximum 'timeout'
    * millisecondes l'obtention de la connection.
    * 
    * @param timeout
    *          Temps d'attente maximum de la connection
    * @throws java.sql.SQLException
    *           Exception SQL
    * @return java.sql.Connection Connection à la base de données
    */
   protected synchronized PersistenceManager getPersistenceManager(long timeout)
       throws ATGDaoBaseIndisponibleException
   {
     long startTime = System.currentTimeMillis(); // heure d'appel à la fonction
     long remaining = timeout; // temps restant
     PersistenceManager conn = null; // connection à la base
 
     while ((conn = getPooledPersistenceManager()) == null)
     {
       // la connection n'a pas ete obtenue...
       try
       {
         // attente du delai souhaité
         // le processus est reveillé des qu'une connection se libère
         logFinest("Attente d'une connection (" + timeout + ").");
         wait(timeout);
       }
       catch (InterruptedException exception)
       {
         // le processus d'attente est interrompu
       }
 
       // calcul du temps restant - temps que l'on peut encore passer
       // à attendre
       remaining = timeout - (System.currentTimeMillis() - startTime);
 
       if (remaining <= 0)
       {
         // le delai d'attente est expiré
         throw new ATGDaoBaseIndisponibleException(
             "getPersistenceManager() time-out");
       }
     }
     // vérifie si la connexion demeure valide
     if (!isConnectionOk(conn))
     {
       // problème de connexion => refaire une tentative avec le delai restant
       return getPersistenceManager(remaining);
     }
 
     // mise a jour des informations de suivi
     checkedOut++;
 
     return conn;
   }
 
   /**
    * Renvoie une connection.
    * 
    * @throws ATGDaoBaseIndisponibleException
    * @return PersistenceManager Connection au gestionnaire de persistance
    */
   protected PersistenceManager getPooledPersistenceManager()
       throws ATGDaoBaseIndisponibleException
   {
     PersistenceManager conn = null;
 
     // gestion des traces
     logFinest("Une connection est demandee au pool.");
 
     // existe t'il une connection de libre ?
     if (freeConnections.size() > 0)
     {
       // la première est récupèrée
       conn = (PersistenceManager) freeConnections.firstElement();
       freeConnections.removeElementAt(0);
     }
     else
     {
       // le nombre maximum des connexions creees a ete atteint
       // => essai de liberation
       if (checkedOut == MAX_CONNECTION)
       {
         logWarning("Attention, le nombre maximum de connexions creees sur le serveur de persitance est atteint : "
             + MAX_CONNECTION);
         ckeckCtrlConnexion();
       }
 
       // rmq : pas de 'else' car ckeckCtrlConnexion() peut avoir libere des
       // connexions
       // et mis a jour 'checkedOut'
 
       // il n'existe pas de connection de libre => on en crée une nouvelle
       // (dans la limite)
       if (checkedOut < MAX_CONNECTION) conn = newConnection();
     }
 
     return conn;
   }
 
   /**
    * Vérifie si toutes les connexions ont bien été rendues au pool.
    */
   public void ckeckCtrlConnexion()
   {
     // liste des connexions
     java.util.Enumeration conns = ctrlConnexion.keys();
 
     // parcours des connexions et verification de leur validité
     do
     {
       Object conn = conns.nextElement();
       long delta = System.currentTimeMillis()
           - ((Long) (ctrlConnexion.get(conn))).longValue();
       if ((!freeConnections.contains(conn)) && (delta > MAX_CTRL_TIME))
       {
         // la connexion est consideree comme perdue
         // => on la libere
         ctrlConnexion.remove(conn);
         logSevere("La connexion " + conn
             + " est consideree comme perdue : elle n'a pas ete rendue au pool.");
         // le plus important : mise à jour du compteur de connexions
         checkedOut--;
 
         // fermeture de la connexion
         ((PersistenceManager) conn).close();
       }
     }
     while (conns.hasMoreElements());
   }
 
   /**
    * Création d'une nouvelle connection.
    * 
    * @throws ATGDaoBaseIndisponibleException
    * @return PersistenceManager Nouvelle connection à la base de données
    */
   protected PersistenceManager newConnection()
       throws ATGDaoBaseIndisponibleException
   {
     this.logFinest("Demande d'une reférence sur le Serveur de persistance");
     PersistenceManager pm = (PersistenceManager) this.pmf
         .getPersistenceManager();
     if (pm != null)
     {
       logFinest("  getPersistenceManager()");
       //pm.currentTransaction().begin();
     }
     else
     {
       logSevere("Impossible de récupérer une instance de persistance manager");
     }
     return pm;
   }
 
   /**
    * Contrôle si la connection specifiée est valide.
    * 
    * @param conn
    *          Connection à tester
    * @return boolean Connection valide ou non
    */
   protected boolean isConnectionOk(PersistenceManager conn)
   {
 
     // deux tests sonr réalisé sur la connection
     // 1 - connection fermée ?
     if (!conn.isClosed())
     {
       conn.refreshAll();
       return true;
     }
     else
       return false;
 
   }
 
   /**
    * Renvoie l'instance unique du pool de connections pour la référence donnée.
    * 
    * @param reference
    *          Référence du pool de connection
    * @return StdPoolDataSource Instance d'un pool d'accès aux données
    */
   static public ATGDaoJdoPoolDataSource getInstance(String reference)
   {
     if ((instances.get(reference) != null))
     {
       // l'instance pour cette référence existe déjà
       return (ATGDaoJdoPoolDataSource) (instances.get(reference));
     }
     else
     {
       // création de l'instance 'reference'
       ATGDaoJdoPoolDataSource instance = new ATGDaoJdoPoolDataSource(reference);
       // initialisation de cette instance
       instance.initPool();
       // ajout de l'instance à la liste des instances
       instances.put(reference, instance);
 
       return instance;
     }
   }
 
   /**
    * Initialisation du pool. Appelé lors de l'instanciation.
    */
   protected void initPool()
   {
     freeConnections = new java.util.Vector();
 
     // un certain nombre de connections sont créees automatiquement
     // lors de l'instanciation du pool
     for (int i = 0; i < START_CONNECTION; i++)
     {
       try
       {
         freeConnections.addElement(newConnection());
       }
       catch (ATGDaoBaseIndisponibleException exception)
       {
         logSevere("Impossible d'initialiser le pool de Connection Jdo!"
             + exception.getCause() + " / " + exception.getMessage());
       }
     }
   }
   /**
    * Libére la connection spécifiée.
    * @param conn Connection à libérer
    */
   public synchronized void release(PersistenceManager conn) {
     // gestion des traces
     logFinest("Un persistance manager est liberee : " +
               (freeConnections.size() + 1) + " persistance manager sont libres.");
 
     // la connection est recyclee - ajout à la liste des connections libres
     freeConnections.addElement(conn);
     checkedOut--;
 
     // on signale aux processus qui 'dorment' (attente d'une connection)
     // qu'une connection vient de se liberer
     notifyAll();
   }  
 }