package atg.metier.dao.jdbc;
   
   import java.sql.Connection;
   import java.sql.SQLException;
   import atg.metier.dao.jdbc.exception.ATGDaoBaseIndisponibleException;
   import atg.service.constante.AtgConstantes;
   import atg.service.log.AtgLogManager;
   
   /**
   * <p>Titre : Pool de connexions aux bases de données en JDBCs</p>
   * <p>Description : Gestion de pool de connexion</p>
   * <p>Copyright : FERRARI Olivier</p>
   * @author  BOSC Frédéric repris et modifié par FERRARI Olivier
   * @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.
   */
  
  public class ATGDaoPoolDataSource
      extends atg.util.service.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();
  
    /**
     *  Commande à executer sur la connexion nouvellement créées
     */
    private static java.util.Hashtable connexionRequests = 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 = null;
  
    /**
     * ensemble des connections creees sur la base de donnees
    */
   protected java.util.Hashtable ctrlConnexion = null;
 
 //***************************************************************************
 //                          Constructeurs
 //***************************************************************************
 
     /**
      * Constructeur.
      * Récupère les informations relatives aux connections.
      * @param newReference Référence du pool de connection
      */
     private ATGDaoPoolDataSource(String newReference) {
       reference = newReference;
       ctrlConnexion = new java.util.Hashtable();
 
       if (newReference.equals(CSTE_DEFAULT_REFERENCE)) {
         DRIVER_NAME = atg.service.constante.AtgConstantesWF.DB_DRIVER_NAME;
         USER_NAME = atg.service.constante.AtgConstantesWF.DB_USER_NAME;
         USER_PWD = atg.service.constante.AtgConstantesWF.DB_PWD;
         DB_NAME = atg.service.constante.AtgConstantesWF.DB_DB_NAME;
       }
       else {
         DRIVER_NAME = atg.service.constante.AtgConstantesWF.getValue(
             newReference +
             "_DB_DRIVER_NAME");
         USER_NAME = atg.service.constante.AtgConstantesWF.getValue(newReference +
             "_DB_USER_NAME");
         USER_PWD = atg.service.constante.AtgConstantesWF.getValue(newReference +
             "_DB_PWD");
         DB_NAME = atg.service.constante.AtgConstantesWF.getValue(newReference +
             "_DB_DB_NAME");
       }
     }
 
 //***************************************************************************
 //                          Méthodes statiques
 //***************************************************************************
 
     /**
          * Fixe la commande à executer lors de la création d'une nouvelle connexion.
      * @param reference Référence du pool de connection
      * @param connexionRequest Commande sql à executer
      */
     static public void setConnexionRequest(String reference,
                                            String connexionRequest) {
       connexionRequests.put(reference, connexionRequest);
     }
 
   /**
    * Fixe la commande à executer lors de la création d'une nouvelle connexion.
    * La référence de la base correspond à la référence par défaut.
    * @param connexionRequest Commande sql à executer
    */
   static public void setConnexionRequest(String connexionRequest) {
     connexionRequests.put(CSTE_DEFAULT_REFERENCE, connexionRequest);
   }
 
   /**
    * 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 ATGDaoPoolDataSource getInstance(String reference) {
     if ( (instances.get(reference) != null)) {
       // l'instance pour cette référence existe déjà
       return (ATGDaoPoolDataSource) (instances.get(reference));
     }
     else {
       // création de l'instance 'reference'
       ATGDaoPoolDataSource instance = new ATGDaoPoolDataSource(reference);
       // initialisation de cette instance
       instance.initPool();
       // ajout de l'instance à la liste des instances
       instances.put(reference, instance);
 
       return instance;
     }
   }
 
   /**
    * Renvoie l'instance unique du pool de connections par défaut.
    * @return StdPoolDataSource Instance d'un pool d'accès aux données
    */
   static public ATGDaoPoolDataSource getInstance() {
     return getInstance(CSTE_DEFAULT_REFERENCE);
   }
 
 //***************************************************************************
 //                          Méthodes publiques
 //***************************************************************************
 
     /**
      * Renvoie une connection à la base de donnees.
      * @return java.sql.Connection Connection à la base de données
      */
     public java.sql.Connection getConnection() throws
         ATGDaoBaseIndisponibleException {
       try {
         java.sql.Connection conn = getConnection(MAX_WAIT);
         if (conn != null)
           addCtrlConnexion(conn);
 
         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();
       }
     }
 
 //***************************************************************************
 //                          Méthodes protected
 //***************************************************************************
 
     /**
      * 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 !" +
                     exception.getCause() + " / " + exception.getMessage());
         }
       }
     }
 
   /**
    * 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 java.sql.Connection getConnection(long timeout) throws
       ATGDaoBaseIndisponibleException {
     long startTime = System.currentTimeMillis(); // heure d'appel à la fonction
     long remaining = timeout; // temps restant
     java.sql.Connection conn = null; // connection à la base
 
     while ( (conn = getPooledConnection()) == 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("getConnection() time-out");
       }
     }
     // vérifie si la connexion demeure valide
     if (!isConnectionOk(conn)) {
       // problème de connexion => refaire une tentative avec le delai restant
       return getConnection(remaining);
     }
 
     // mise a jour des informations de suivi
     checkedOut++;
 
     return conn;
   }
 
   /**
    * Contrôle si la connection specifiée est valide.
    * @param conn Connection à tester
    * @return boolean Connection valide ou non
    */
   protected boolean isConnectionOk(java.sql.Connection conn) {
     java.sql.Statement testStmt = null;
 
     // deux tests sonr réalisé sur la connection
     try {
       // 1 - connection fermée ?
       if (!conn.isClosed()) {
         // 2 - est il possible de créer un statement ?
         testStmt = conn.createStatement();
         testStmt.close();
       }
       else
         return false;
     }
     catch (java.sql.SQLException exceptionConnection) {
       if (testStmt != null) {
         try {
           testStmt.close();
         }
         catch (java.sql.SQLException exceptionStatement) {
           // laissé vide intensionnellement
         }
       }
 
       return false;
     }
 
     return true;
   }
 
   /**
    * Renvoie une connection.
    * @throws ATGDaoBaseIndisponibleException
    * @return java.sql.Connection Connection à la base de données
    */
   protected java.sql.Connection getPooledConnection() throws
       ATGDaoBaseIndisponibleException {
     java.sql.Connection 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 = (java.sql.Connection) 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 la base 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;
   }
 
   /**
    * Création d'une nouvelle connection.
    * @throws ATGDaoBaseIndisponibleException
    * @return java.sql.Connection Nouvelle connection à la base de données
    */
   protected java.sql.Connection newConnection() throws
       ATGDaoBaseIndisponibleException {
     // instantiation du driver (si nécèssaire)
     if (driver == null) {
       try {
         Class clazz = Class.forName(DRIVER_NAME);
         logFinest("Classe du driver trouvee : " + clazz.toString());
         driver = (java.sql.Driver) clazz.newInstance();
       }
       catch (Throwable exception) {
         logSevere("Impossible de creer l'instance : " + DRIVER_NAME + "  " +
                   exception.getMessage());
         throw new ATGDaoBaseIndisponibleException(exception.getMessage());
       }
     }
 
     // initialisation des paramètres de connection
     java.util.Properties props = new java.util.Properties();
     if (USER_NAME != null)
       props.put("user", USER_NAME);
     if (USER_PWD != null)
       props.put("password", USER_PWD);
 
       // obtention d'une connection
     Connection conn = null;
     try {
       conn = driver.connect(DB_NAME, props);
     }
     catch (SQLException ex) {
       ex.printStackTrace();
       logSevere("Connection JDBC impossible à créer  par le pool " +
                 DRIVER_NAME + " " + USER_NAME + " " + USER_PWD + " " + DB_NAME);
       throw new ATGDaoBaseIndisponibleException("Impossible de créer une connexion par pool");
     }
 
     // gestion des traces
     logFinest("Une nouvelle connection JDBC est creee par le pool " +
               DRIVER_NAME + " " + USER_NAME + " " + USER_PWD + " " + DB_NAME);
 
     if (conn == null)
       logSevere("Impossible de creer une connection : " + DRIVER_NAME + " " +
                 USER_NAME + " " + USER_PWD + " " + DB_NAME);
     else {
       // la méthode à appliquer sur toute nouvelle connexion est executée
       // (si nécessaire)
       try {
         if (connexionRequests.get(reference) != null) {
           java.sql.PreparedStatement statement = conn.prepareStatement( (String) (
               connexionRequests.get(reference)));
           statement.executeUpdate();
           logFinest(
               "La commande d'alteration de la connexion a ete realisee : " +
               (String) (connexionRequests.get(reference)) + ".");
         }
         else
           logFinest(
               "Il n'existe pas de commande d'alteration sur la connexion.");
       }
       catch (Exception exception) {
         logSevere(
             "Impossible d'effectuer la requete d'alteration de la connexion !  " +
             exception.getMessage());
       }
     }
 
     return conn;
   }
 
   /**
    * Libére la connection spécifiée.
    * @param conn Connection à libérer
    */
   public synchronized void release(java.sql.Connection conn) {
     // gestion des traces
     logFinest("Une connection JDBC est liberee : " +
               (freeConnections.size() + 1) + " connections 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();
   }
 
   /**
    * Retourne le nombre de bases de données.
    * @return int Nombre de bases de données
    */
   public static int getNumberOfDataBase() {
     if (instances == null)
       return 0;
     else
       return instances.size();
   }
 
   /**
    * Ajoute une connexion au mécanisme de contrôle.
    * @param conn Connexion à ajouter
    */
   public void addCtrlConnexion(java.sql.Connection conn) {
     ctrlConnexion.put(conn, new Long(System.currentTimeMillis()));
   }
 
   /**
    * 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
         try {
           ( (java.sql.Connection) conn).close();
         }
         catch (java.sql.SQLException sqlException) {
           // laissé vide intensionnellement
         }
       }
     }
     while (conns.hasMoreElements());
   }
 
   /**
    * Retourne le temps maximum d'attente d'une connexion par défaut.
    * @return int Temps maximum d'attente d'une connexion par défaut.
    */
   public static int getMaxWait() {
     return MAX_WAIT;
   }
 
   /**
    * Retourne le nombre maximun de connexions créées par le pool.
    * @return int Nombre maximun de connexions créées par le pool.
    */
   public static int getMaxConnection() {
     return MAX_CONNECTION;
   }
 
   /**
    * Retourne le nombre de connexions que créait le pool au démarrage.
    * @return int Nombre de connexions que créait le pool au démarrage.
    */
   public static int getStartConnection() {
     return START_CONNECTION;
   }
 
   protected static java.util.logging.Logger logger_ = null;
   /**
    * Ecriture des logs
    */
 
   protected java.util.logging.Logger getLogger() {
     if (logger_ == null)
       logger_ = AtgLogManager.getLog(AtgConstantes.
                                      ATG_LOG_CATEGORY_METIER_DAO_JDBC);
 
     return logger_;
   }
 
 }