package org.apache.ojb.broker.util.logging;

 /* Copyright 2002-2005 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.

  */

 import java.io.InputStream;

 import java.io.File;

 import java.util.Properties;

 import java.net.URL;

 import org.apache.ojb.broker.util.ClassHelper;

 import org.apache.ojb.broker.util.configuration.impl.ConfigurationAbstractImpl;

 import org.apache.commons.lang.SystemUtils;

 /**

  * Provides the configuration for the logging. Note that this is separated from the OJB

  * configuration.

  * 

  * @version $Id: LoggingConfiguration.java,v 1.1 2007-08-24 22:17:32 ewestfal Exp $

  */

 public class LoggingConfiguration extends ConfigurationAbstractImpl

 {

     /** The commons-logging property denoting which log to use. This property

      *  is repeated here to avoid making this class dependent upon commons-logging */

     public static final String PROPERTY_COMMONS_LOGGING_LOG = "org.apache.commons.logging.Log";

     /** The commons-logging property denoting which log factory to use. This property

      *  is repeated here to avoid making this class dependent upon commons-logging */

     public static final String PROPERTY_COMMONS_LOGGING_LOGFACTORY = "org.apache.commons.logging.LogFactory";

     /** The property denoting the OJB logger class */

     public static final String PROPERTY_OJB_LOGGERCLASS      = "org.apache.ojb.broker.util.logging.Logger.class";

     /** The property denoting the config file for the OJB logger class */

     public static final String PROPERTY_OJB_LOGGERCONFIGFILE = "org.apache.ojb.broker.util.logging.Logger.configFile";

     /** Default filename of the OJB logging properties file */

     public static final String OJB_LOGGING_PROPERTIES_FILE = "OJB-logging.properties";

     /** Default log level */

     public static final String OJB_DEFAULT_LOG_LEVEL = "WARN";

     /** Default boot log level */

     public static final String OJB_DEFAULT_BOOT_LOG_LEVEL = "INFO";

     /** The logger class */

     private Class  _loggerClass;

     /** The config file for the logger */

     private String _loggerConfigFile;

     /**

      * Creates a new logging configuration object which automatically initializes itself.

      */

     public LoggingConfiguration()

     {

         super();

     }

     /* (non-Javadoc)

      * @see org.apache.ojb.broker.util.configuration.impl.ConfigurationAbstractImpl#load()

      */

     protected void load()

     {

         Logger bootLogger = LoggerFactory.getBootLogger();

         // first we check whether the system property

         //   org.apache.ojb.broker.util.logging.Logger

         // is set (or its alias LoggerClass which is deprecated)

         ClassLoader contextLoader   = ClassHelper.getClassLoader();

         String      loggerClassName;

         _loggerClass      = null;

         properties        = new Properties();

         loggerClassName   = getLoggerClass(System.getProperties());

         _loggerConfigFile = getLoggerConfigFile(System.getProperties());

         InputStream ojbLogPropFile;

         if (loggerClassName == null)

         {

             // now we're trying to load the OJB-logging.properties file

             String ojbLogPropFilePath = System.getProperty(OJB_LOGGING_PROPERTIES_FILE, OJB_LOGGING_PROPERTIES_FILE);

             try

             {

                 URL ojbLoggingURL = ClassHelper.getResource(ojbLogPropFilePath);

                 if (ojbLoggingURL == null)

                 {

                     ojbLoggingURL = (new File(ojbLogPropFilePath)).toURL();

                 }

                 ojbLogPropFile = ojbLoggingURL.openStream();

                 try

                 {

                     bootLogger.info("Found logging properties file: " + ojbLogPropFilePath);

                     properties.load(ojbLogPropFile);

                     _loggerConfigFile = getLoggerConfigFile(properties);

                     loggerClassName = getLoggerClass(properties);

                 }

                 finally

                 {

                     ojbLogPropFile.close();

                 }

             }

             catch (Exception ex)

             {

                 if(loggerClassName == null)

                 {

                     bootLogger.warn("Can't read logging properties file using path '" + ojbLogPropFilePath

                             + "', message is: " + SystemUtils.LINE_SEPARATOR + ex.getMessage()

                             + SystemUtils.LINE_SEPARATOR + "Will try to load logging properties from OJB.properties file");

                 }

                 else

                 {

                     bootLogger.info("Problems while closing resources for path '" + ojbLogPropFilePath

                             + "', message is: " + SystemUtils.LINE_SEPARATOR + ex.getMessage(), ex);

                 }

             }

         }

         if (loggerClassName == null)

         {

             // deprecated: load the OJB.properties file

             // this is not good because we have all OJB properties in this config

             String ojbPropFile = System.getProperty("OJB.properties", "OJB.properties");

             try

             {

                 ojbLogPropFile = contextLoader.getResourceAsStream(ojbPropFile);

                 if (ojbLogPropFile != null)

                 {

                     try

                     {

                         properties.load(ojbLogPropFile);

                         loggerClassName   = getLoggerClass(properties);

                         _loggerConfigFile = getLoggerConfigFile(properties);

                         if (loggerClassName != null)

                         {

                             // deprecation warning for after 1.0

                             bootLogger.warn("Please use a separate '"+OJB_LOGGING_PROPERTIES_FILE+"' file to specify your logging settings");

                         }

                     }

                     finally

                     {

                         ojbLogPropFile.close();

                     }

                 }

             }

             catch (Exception ex)

             {}

         }

         if (loggerClassName != null)

         {

             try

             {

                 _loggerClass = ClassHelper.getClass(loggerClassName);

                 bootLogger.info("Logging: Found logger class '" + loggerClassName);

             }

             catch (ClassNotFoundException ex)

             {

                 _loggerClass = PoorMansLoggerImpl.class;

                 bootLogger.warn("Could not load logger class "+loggerClassName+", defaulting to "+_loggerClass.getName(), ex);

             }

         }

         else

         {

             // still no logger configured - lets check whether commons-logging is configured

             if ((System.getProperty(PROPERTY_COMMONS_LOGGING_LOG) != null) ||

                 (System.getProperty(PROPERTY_COMMONS_LOGGING_LOGFACTORY) != null))

             {

                 // yep, so use commons-logging

                 _loggerClass = CommonsLoggerImpl.class;

                 bootLogger.info("Logging: Found commons logging properties, use " + _loggerClass);

             }

             else

             {

                 // but perhaps there is a log4j.properties file ?

                 try

                 {

                     ojbLogPropFile = contextLoader.getResourceAsStream("log4j.properties");

                     if (ojbLogPropFile != null)

                     {

                         // yep, so use log4j

                         _loggerClass      = Log4jLoggerImpl.class;

                         _loggerConfigFile = "log4j.properties";

                         bootLogger.info("Logging: Found 'log4j.properties' file, use " + _loggerClass);

                         ojbLogPropFile.close();

                     }

                 }

                 catch (Exception ex)

                 {}

                 if (_loggerClass == null)

                 {

                     // or a commons-logging.properties file ?

                     try

                     {

                         ojbLogPropFile = contextLoader.getResourceAsStream("commons-logging.properties");

                         if (ojbLogPropFile != null)

                         {

                             // yep, so use commons-logging

                             _loggerClass      = CommonsLoggerImpl.class;

                             _loggerConfigFile = "commons-logging.properties";

                             bootLogger.info("Logging: Found 'commons-logging.properties' file, use " + _loggerClass);

                             ojbLogPropFile.close();

                         }

                     }

                     catch (Exception ex)

                     {}

                     if (_loggerClass == null)

                     {

                         // no, so default to poor man's logging

                         bootLogger.info("** Can't find logging configuration file, use default logger **");

                         _loggerClass = PoorMansLoggerImpl.class;

                     }

                 }

             }

         }

     }

     private String getLoggerClass(Properties props)

     {

         String loggerClassName = props.getProperty(PROPERTY_OJB_LOGGERCLASS);

         if (loggerClassName == null)

         {

             loggerClassName = props.getProperty("LoggerClass");

         }

         return loggerClassName;

     }

     private String getLoggerConfigFile(Properties props)

     {

         String loggerConfigFile = props.getProperty(PROPERTY_OJB_LOGGERCONFIGFILE);

         if (loggerConfigFile == null)

         {

             loggerConfigFile = props.getProperty("LoggerConfigFile");

         }

         return loggerConfigFile;

     }

     public String getLogLevel(String loggerName)

     {

         /*

         arminw:

         use ROOT.LogLevel property to define global

         default log level

         */

         return getString(loggerName + ".LogLevel", getString("ROOT.LogLevel", OJB_DEFAULT_LOG_LEVEL));

     }

     /* (non-Javadoc)

      * @see org.apache.ojb.broker.util.configuration.Configuration#setLogger(org.apache.ojb.broker.util.logging.Logger)

      */

     public void setLogger(Logger loggerInstance)

     {

         // ignored - only logging via the boot logger

     }

     /**

      * Returns the logger class.

      * 

      * @return The logger class

      */

     public Class getLoggerClass()

     {

         return _loggerClass;

     }

     /**

      * Returns the name of the config file for the logger.

      * 

      * @return The config file if it was configured

      */

     public String getLoggerConfigFile()

     {

         return _loggerConfigFile;

     }

 }