/*
    * Created on Aug 30, 2004
    *
    * TODO To change the template for this generated file go to
    * Window - Preferences - Java - Code Style - Code Templates
    */
   package ch.ledcom.hephaistos.dao;
   
   import java.net.URL;
  
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  
  import net.sf.hibernate.SessionFactory;
  import net.sf.hibernate.cfg.Configuration;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.struts.action.ActionServlet;
  import org.apache.struts.action.PlugIn;
  import org.apache.struts.config.ModuleConfig;
  
  /***
   * Implements the <code>PlugIn</code> interface to configure the Hibernate
   * data persistence library.  A configured
   * <code>net.sf.hibernate.SessionFactory</code> is stored in the 
   * <code>ServletContext</code> of the web application unless the property
   * <code>storedInServletContext</code> is set to <code>false</code>.
   * 
   * <p>
   * &lt;plugin class=&quot;net.sf.hibernate.plugins.struts.HibernatePlugIn&quot;&gt;
   *   &lt;set-property name=&quot;configFilePath&quot"
   *                value=&quot;path-to-config-file&quot;/&gt;
   *   &lt;set-property name=&quot;storedInServletContext&quot"
   *                value=&quot;true-or-false&quot;/&gt;
   * &lt;/plugin&gt;
   *
   * @author  <a href="mailto:bhandy@users.sf.net">Bradley M. Handy</a>
   * @version 1.0
   */
  public class HibernatePlugIn implements PlugIn {
      
      /***
       * the key under which the <code>SessionFactory</code> instance is stored
       * in the <code>ServletContext</code>.
       */
      public static final String SESSION_FACTORY_KEY 
              = SessionFactory.class.getName();
  
      private static Log logger = LogFactory.getLog(HibernatePlugIn.class);
      
      /***
       * indicates whether the <code>SessionFactory</code> instance will be stored
       * in the <code>ServletContext</code>, or not.
       */
      private boolean _storedInServletContext = true;
      
      /***
       * the path to the xml configuration file.  the path should start with a
       * '/' character and be relative to the root of the class path.
       * (DEFAULT:  "/hibernate.cfg.xml")
       */
      private String _configFilePath = "/hibernate.cfg.xml";
  
      private ActionServlet _servlet = null;
      private ModuleConfig _config = null;
      private SessionFactory _factory = null;
  
      /***
       * Destroys the <code>SessionFactory</code> instance.
       */
      public void destroy() {
          _servlet = null;
          _config = null;
          
          try {
              logger.debug("Destroying SessionFactory...");
              
              _factory.close();
              
              logger.debug("SessionFactory destroyed...");
          } catch (Exception e) {
              logger.error("Unable to destroy SessionFactory...(exception ignored)",
                      e);
          }
      }
      
      /***
       * Initializes the <code>SessionFactory</code>.
       * @param servlet the <code>ActionServlet</code> instance under which the
       *        plugin will run.
       * @param config the <code>ModuleConfig</code> for the module under which
       *        the plugin will run.
       */
      public void init(ActionServlet servlet, ModuleConfig config)
      throws ServletException {
          _servlet = servlet;
          _config = config;
  
         initHibernate();
     }
     
     /***
      * Initializes Hibernate with the config file found at
      * <code>configFilePath</code>.
      */
     private void initHibernate() throws ServletException {
         Configuration configuration = null;
         URL configFileURL = null;
         ServletContext context = null;
         
         try {
             configFileURL = HibernatePlugIn.class.getResource(_configFilePath);
 
             context = _servlet.getServletContext();
 
             if (logger.isDebugEnabled()) {
                 logger.debug("Initializing Hibernate from "
                         + _configFilePath + "...");
             }
             
             configuration = (new Configuration()).configure(configFileURL);
             _factory = configuration.buildSessionFactory();
             
             if (_storedInServletContext) {
                 logger.debug("Storing SessionFactory in ServletContext, using key : " + SESSION_FACTORY_KEY);
                 
                 context.setAttribute(SESSION_FACTORY_KEY, _factory);
             }
            
         } catch (Throwable t) {
             logger.error("Exception while initializing Hibernate.");
             logger.error("Rethrowing exception...", t);
             
             throw (new ServletException(t));
         }
     }
     
     /***
      * Setter for property configFilePath.
      * @param configFilePath New value of property configFilePath.
      */
     public void setConfigFilePath(String configFilePath) {
         if ((configFilePath == null) || (configFilePath.trim().length() == 0)) {
             throw new IllegalArgumentException(
                     "configFilePath cannot be blank or null.");
         }
         
         if (logger.isDebugEnabled()) {
             logger.debug("Setting 'configFilePath' to '"
                     + configFilePath + "'...");
         }
         
         _configFilePath = configFilePath;
     }
     
     /***
      * Setter for property storedInServletContext.
      * @param storedInServletContext New value of property storedInServletContext.
      */
     public void setStoredInServletContext(String storedInServletContext) {
         if ((storedInServletContext == null) 
                 || (storedInServletContext.trim().length() == 0)) {
             storedInServletContext = "false";
         }
         
         if (logger.isDebugEnabled()) {
             logger.debug("Setting 'storedInServletContext' to '"
                     + storedInServletContext + "'...");
         }
         
         _storedInServletContext 
                 = new Boolean(storedInServletContext).booleanValue();
     }
     
 }