package org.apache.jetspeed.services.logging;
   
   /*
    * Copyright 2001,2004 The Apache Software Foundation.
    * 
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
   *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  // Java classes
  import javax.servlet.ServletConfig;
  import javax.servlet.ServletContext;
  
  // Jetspeed classes
  import org.apache.jetspeed.services.resources.JetspeedResources;
  
  // Log4J classes
  import org.apache.log4j.LogManager;
  import org.apache.log4j.Logger;
  import org.apache.log4j.PropertyConfigurator;
  import org.apache.log4j.xml.DOMConfigurator;
  
  // Turbine classes
  import org.apache.turbine.Turbine;
  import org.apache.turbine.services.InitializationException;
  import org.apache.turbine.services.TurbineBaseService;
  
  /***
   * The default implementation of the logging service in Jetspeed.
   *
   * This service initializes the underlying logging implementation, 
   * and acts as a factory for loggers.
   * The current implementation uses Log4J.
   *
   * @see org.apache.log4j.LogManager
   * @see org.apache.log4j.Logger
   * @author <a href="mailto:harald@ommang.com">Harald Ommang</a>
   */
  public class JetspeedLogFactoryService extends TurbineBaseService
  {
  
      public String SERVICE_NAME = "JetspeedLogFactoryService"; 
      private static final String CONFIG_LOG4J_PROPERTIES = "log4j.properties";
      private static final String CONFIG_LOG4J_PROPERTIES_DEFAULT = "/WEB-INF/conf/log4j.properties";
      private static final String CONFIG_LOG4J_AND_WATCH = "log4j.configureAndWatch";
      private static final boolean CONFIG_LOG4J_AND_WATCH_DEFAULT = true;
      private static final String CONFIG_LOG4J_WATCHINTERVAL = "log4j.watchInterval";
      private static final long CONFIG_LOG4J_WATCHINTERVAL_DEFAULT = 60000L;
      private ServletContext context;
      /***
       * Flag to check for initilization. Needed to make time of init more robust.
       * Also, cannot access the init in parent class from static method
       */        
      private static boolean initDone = false;
          
      /***
       * Default constructor
       */    
      public JetspeedLogFactoryService()
      {
          context = null;
      }    
     
      /***
       * Initializes the service by getting the servlet configuration from Turbine
       *
       * @throws InitializationException Initialization failed
       */ 
      public void init() throws InitializationException
      {
          ServletConfig conf = Turbine.getTurbineServletConfig();
          if(conf != null)
          {
              init(conf);
          }
      }
  
      /***
       * Initializes the service with the given configuration
       * Initializes the underlying logging implementation, Log4J
       *
       * @param config The ServletConfiguration from Turbine
       *
       * @throws InitializationException Initialization failed
       */    
      public void init(ServletConfig config) throws InitializationException
      {
          context = config.getServletContext();
          String log4jProperties = JetspeedResources.getString(CONFIG_LOG4J_PROPERTIES, CONFIG_LOG4J_PROPERTIES_DEFAULT);
          if(log4jProperties != null)
         {
             try
             {
                 String fileName = Turbine.getRealPath(log4jProperties);
                 boolean watch = JetspeedResources.getBoolean(CONFIG_LOG4J_AND_WATCH, CONFIG_LOG4J_AND_WATCH_DEFAULT);
                 long watchInterval = JetspeedResources.getLong(CONFIG_LOG4J_WATCHINTERVAL, CONFIG_LOG4J_WATCHINTERVAL_DEFAULT);
                 System.setProperty("webappRoot", context.getRealPath("/"));
                 
                 // Check to see if property or XML configuration is to be used.
                 if(fileName.endsWith(".properties"))
                 {
                     if(watch)
                     {
                         // Configure with a property file and watch for changes
                         PropertyConfigurator.configureAndWatch(fileName, watchInterval);
                     } 
                     else
                     {
                         PropertyConfigurator.configure(fileName);
                     }
                 } 
                 else
                 {
                     if(watch)
                     {
                         // Configure with an XML file and watch for changes
                         DOMConfigurator.configureAndWatch(fileName, watchInterval);
                     } 
                     else
                     {
                         DOMConfigurator.configure(fileName);
                     }
                 }
             }
             catch(Exception e)
             {
                 throw new InitializationException("Failed to load " + log4jProperties + " - " + e.toString());
             }
         }
         setInit(true);
         initDone = true;
     } // init
 
     /***
      * The actual Factory method that gets the appropriate logger from Log4j and
      * wraps it in a JetspeedLogger
      */        
     public static JetspeedLogger getLogger(String loggerName)
     {
         // This test needed to ensure correct init sequence between this and services that log.
         if (!initDone)
         {
             synchronized (JetspeedLogFactoryService.class)
             {
                  if (!initDone)
                 { 
                     try 
                     {
                         new JetspeedLogFactoryService().init();
                     }
                     catch(Exception e)
                     {
                         System.err.println("Init failed no logging available" + e.getMessage());
                         e.printStackTrace();
                     }
                  }
             }
         }
         Logger newLog = LogManager.getLogger(loggerName);
         JetspeedLogger newLogger = new JetspeedLogger(newLog);
         return newLogger;
     }
 } // class JetspeedLogFactoryService