| #region Apache License |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one or more |
| // contributor license agreements. See the NOTICE file distributed with |
| // this work for additional information regarding copyright ownership. |
| // The ASF licenses this file to you 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. |
| // |
| #endregion |
| |
| // .NET Compact Framework 1.0 has no support for reading assembly attributes |
| #if !NETCF |
| |
| using System; |
| using System.Collections; |
| using System.Reflection; |
| using System.IO; |
| |
| using log4net.Util; |
| using log4net.Repository; |
| using log4net.Repository.Hierarchy; |
| |
| namespace log4net.Config |
| { |
| /// <summary> |
| /// Assembly level attribute to configure the <see cref="XmlConfigurator"/>. |
| /// </summary> |
| /// <remarks> |
| /// <para> |
| /// This attribute may only be used at the assembly scope and can only |
| /// be used once per assembly. |
| /// </para> |
| /// <para> |
| /// Use this attribute to configure the <see cref="XmlConfigurator"/> |
| /// without calling one of the <see cref="M:XmlConfigurator.Configure()"/> |
| /// methods. |
| /// </para> |
| /// <para> |
| /// If neither of the <see cref="ConfigFile"/> or <see cref="ConfigFileExtension"/> |
| /// properties are set the configuration is loaded from the application's .config file. |
| /// If set the <see cref="ConfigFile"/> property takes priority over the |
| /// <see cref="ConfigFileExtension"/> property. The <see cref="ConfigFile"/> property |
| /// specifies a path to a file to load the config from. The path is relative to the |
| /// application's base directory; <see cref="AppDomain.BaseDirectory"/>. |
| /// The <see cref="ConfigFileExtension"/> property is used as a postfix to the assembly file name. |
| /// The config file must be located in the application's base directory; <see cref="AppDomain.BaseDirectory"/>. |
| /// For example in a console application setting the <see cref="ConfigFileExtension"/> to |
| /// <c>config</c> has the same effect as not specifying the <see cref="ConfigFile"/> or |
| /// <see cref="ConfigFileExtension"/> properties. |
| /// </para> |
| /// <para> |
| /// The <see cref="Watch"/> property can be set to cause the <see cref="XmlConfigurator"/> |
| /// to watch the configuration file for changes. |
| /// </para> |
| /// <note> |
| /// <para> |
| /// Log4net will only look for assembly level configuration attributes once. |
| /// When using the log4net assembly level attributes to control the configuration |
| /// of log4net you must ensure that the first call to any of the |
| /// <see cref="log4net.Core.LoggerManager"/> methods is made from the assembly with the configuration |
| /// attributes. |
| /// </para> |
| /// <para> |
| /// If you cannot guarantee the order in which log4net calls will be made from |
| /// different assemblies you must use programmatic configuration instead, i.e. |
| /// call the <see cref="M:XmlConfigurator.Configure()"/> method directly. |
| /// </para> |
| /// </note> |
| /// </remarks> |
| /// <author>Nicko Cadell</author> |
| /// <author>Gert Driesen</author> |
| [AttributeUsage(AttributeTargets.Assembly)] |
| [Serializable] |
| public /*sealed*/ class XmlConfiguratorAttribute : ConfiguratorAttribute |
| { |
| // |
| // Class is not sealed because DOMConfiguratorAttribute extends it while it is obsoleted |
| // |
| |
| /// <summary> |
| /// Default constructor |
| /// </summary> |
| /// <remarks> |
| /// <para> |
| /// Default constructor |
| /// </para> |
| /// </remarks> |
| public XmlConfiguratorAttribute() : base(0) /* configurator priority 0 */ |
| { |
| } |
| |
| #region Public Instance Properties |
| |
| /// <summary> |
| /// Gets or sets the filename of the configuration file. |
| /// </summary> |
| /// <value> |
| /// The filename of the configuration file. |
| /// </value> |
| /// <remarks> |
| /// <para> |
| /// If specified, this is the name of the configuration file to use with |
| /// the <see cref="XmlConfigurator"/>. This file path is relative to the |
| /// <b>application base</b> directory (<see cref="AppDomain.BaseDirectory"/>). |
| /// </para> |
| /// <para> |
| /// The <see cref="ConfigFile"/> takes priority over the <see cref="ConfigFileExtension"/>. |
| /// </para> |
| /// </remarks> |
| public string ConfigFile |
| { |
| get { return m_configFile; } |
| set { m_configFile = value; } |
| } |
| |
| /// <summary> |
| /// Gets or sets the extension of the configuration file. |
| /// </summary> |
| /// <value> |
| /// The extension of the configuration file. |
| /// </value> |
| /// <remarks> |
| /// <para> |
| /// If specified this is the extension for the configuration file. |
| /// The path to the config file is built by using the <b>application |
| /// base</b> directory (<see cref="AppDomain.BaseDirectory"/>), |
| /// the <b>assembly file name</b> and the config file extension. |
| /// </para> |
| /// <para> |
| /// If the <see cref="ConfigFileExtension"/> is set to <c>MyExt</c> then |
| /// possible config file names would be: <c>MyConsoleApp.exe.MyExt</c> or |
| /// <c>MyClassLibrary.dll.MyExt</c>. |
| /// </para> |
| /// <para> |
| /// The <see cref="ConfigFile"/> takes priority over the <see cref="ConfigFileExtension"/>. |
| /// </para> |
| /// </remarks> |
| public string ConfigFileExtension |
| { |
| get { return m_configFileExtension; } |
| set { m_configFileExtension = value; } |
| } |
| |
| /// <summary> |
| /// Gets or sets a value indicating whether to watch the configuration file. |
| /// </summary> |
| /// <value> |
| /// <c>true</c> if the configuration should be watched, <c>false</c> otherwise. |
| /// </value> |
| /// <remarks> |
| /// <para> |
| /// If this flag is specified and set to <c>true</c> then the framework |
| /// will watch the configuration file and will reload the config each time |
| /// the file is modified. |
| /// </para> |
| /// <para> |
| /// The config file can only be watched if it is loaded from local disk. |
| /// In a No-Touch (Smart Client) deployment where the application is downloaded |
| /// from a web server the config file may not reside on the local disk |
| /// and therefore it may not be able to watch it. |
| /// </para> |
| /// <note> |
| /// Watching configuration is not supported on the SSCLI. |
| /// </note> |
| /// </remarks> |
| public bool Watch |
| { |
| get { return m_configureAndWatch; } |
| set { m_configureAndWatch = value; } |
| } |
| |
| #endregion Public Instance Properties |
| |
| #region Override ConfiguratorAttribute |
| |
| /// <summary> |
| /// Configures the <see cref="ILoggerRepository"/> for the specified assembly. |
| /// </summary> |
| /// <param name="sourceAssembly">The assembly that this attribute was defined on.</param> |
| /// <param name="targetRepository">The repository to configure.</param> |
| /// <remarks> |
| /// <para> |
| /// Configure the repository using the <see cref="XmlConfigurator"/>. |
| /// The <paramref name="targetRepository"/> specified must extend the <see cref="Hierarchy"/> |
| /// class otherwise the <see cref="XmlConfigurator"/> will not be able to |
| /// configure it. |
| /// </para> |
| /// </remarks> |
| /// <exception cref="ArgumentOutOfRangeException">The <paramref name="targetRepository" /> does not extend <see cref="Hierarchy"/>.</exception> |
| override public void Configure(Assembly sourceAssembly, ILoggerRepository targetRepository) |
| { |
| IList configurationMessages = new ArrayList(); |
| |
| using (new LogLog.LogReceivedAdapter(configurationMessages)) |
| { |
| string applicationBaseDirectory = null; |
| try |
| { |
| applicationBaseDirectory = SystemInfo.ApplicationBaseDirectory; |
| } |
| catch |
| { |
| // Ignore this exception because it is only thrown when ApplicationBaseDirectory is a file |
| // and the application does not have PathDiscovery permission |
| } |
| |
| if (applicationBaseDirectory == null || (new Uri(applicationBaseDirectory)).IsFile) |
| { |
| ConfigureFromFile(sourceAssembly, targetRepository); |
| } |
| else |
| { |
| ConfigureFromUri(sourceAssembly, targetRepository); |
| } |
| } |
| |
| targetRepository.ConfigurationMessages = configurationMessages; |
| } |
| |
| #endregion |
| |
| /// <summary> |
| /// Attempt to load configuration from the local file system |
| /// </summary> |
| /// <param name="sourceAssembly">The assembly that this attribute was defined on.</param> |
| /// <param name="targetRepository">The repository to configure.</param> |
| private void ConfigureFromFile(Assembly sourceAssembly, ILoggerRepository targetRepository) |
| { |
| // Work out the full path to the config file |
| string fullPath2ConfigFile = null; |
| |
| // Select the config file |
| if (m_configFile == null || m_configFile.Length == 0) |
| { |
| if (m_configFileExtension == null || m_configFileExtension.Length == 0) |
| { |
| // Use the default .config file for the AppDomain |
| try |
| { |
| fullPath2ConfigFile = SystemInfo.ConfigurationFileLocation; |
| } |
| catch(Exception ex) |
| { |
| LogLog.Error(declaringType, "XmlConfiguratorAttribute: Exception getting ConfigurationFileLocation. Must be able to resolve ConfigurationFileLocation when ConfigFile and ConfigFileExtension properties are not set.", ex); |
| } |
| } |
| else |
| { |
| // Force the extension to start with a '.' |
| if (m_configFileExtension[0] != '.') |
| { |
| m_configFileExtension = "." + m_configFileExtension; |
| } |
| |
| string applicationBaseDirectory = null; |
| try |
| { |
| applicationBaseDirectory = SystemInfo.ApplicationBaseDirectory; |
| } |
| catch(Exception ex) |
| { |
| LogLog.Error(declaringType, "Exception getting ApplicationBaseDirectory. Must be able to resolve ApplicationBaseDirectory and AssemblyFileName when ConfigFileExtension property is set.", ex); |
| } |
| |
| if (applicationBaseDirectory != null) |
| { |
| fullPath2ConfigFile = Path.Combine(applicationBaseDirectory, SystemInfo.AssemblyFileName(sourceAssembly) + m_configFileExtension); |
| } |
| } |
| } |
| else |
| { |
| string applicationBaseDirectory = null; |
| try |
| { |
| applicationBaseDirectory = SystemInfo.ApplicationBaseDirectory; |
| } |
| catch(Exception ex) |
| { |
| LogLog.Warn(declaringType, "Exception getting ApplicationBaseDirectory. ConfigFile property path ["+m_configFile+"] will be treated as an absolute path.", ex); |
| } |
| |
| if (applicationBaseDirectory != null) |
| { |
| // Just the base dir + the config file |
| fullPath2ConfigFile = Path.Combine(applicationBaseDirectory, m_configFile); |
| } |
| else |
| { |
| fullPath2ConfigFile = m_configFile; |
| } |
| } |
| |
| if (fullPath2ConfigFile != null) |
| { |
| ConfigureFromFile(targetRepository, new FileInfo(fullPath2ConfigFile)); |
| } |
| } |
| |
| /// <summary> |
| /// Configure the specified repository using a <see cref="FileInfo"/> |
| /// </summary> |
| /// <param name="targetRepository">The repository to configure.</param> |
| /// <param name="configFile">the FileInfo pointing to the config file</param> |
| private void ConfigureFromFile(ILoggerRepository targetRepository, FileInfo configFile) |
| { |
| #if (SSCLI) |
| if (m_configureAndWatch) |
| { |
| LogLog.Warn(declaringType, "XmlConfiguratorAttribute: Unable to watch config file not supported on SSCLI"); |
| } |
| XmlConfigurator.Configure(targetRepository, configFile); |
| #else |
| // Do we configure just once or do we configure and then watch? |
| if (m_configureAndWatch) |
| { |
| XmlConfigurator.ConfigureAndWatch(targetRepository, configFile); |
| } |
| else |
| { |
| XmlConfigurator.Configure(targetRepository, configFile); |
| } |
| #endif |
| } |
| |
| /// <summary> |
| /// Attempt to load configuration from a URI |
| /// </summary> |
| /// <param name="sourceAssembly">The assembly that this attribute was defined on.</param> |
| /// <param name="targetRepository">The repository to configure.</param> |
| private void ConfigureFromUri(Assembly sourceAssembly, ILoggerRepository targetRepository) |
| { |
| // Work out the full path to the config file |
| Uri fullPath2ConfigFile = null; |
| |
| // Select the config file |
| if (m_configFile == null || m_configFile.Length == 0) |
| { |
| if (m_configFileExtension == null || m_configFileExtension.Length == 0) |
| { |
| string systemConfigFilePath = null; |
| try |
| { |
| systemConfigFilePath = SystemInfo.ConfigurationFileLocation; |
| } |
| catch(Exception ex) |
| { |
| LogLog.Error(declaringType, "XmlConfiguratorAttribute: Exception getting ConfigurationFileLocation. Must be able to resolve ConfigurationFileLocation when ConfigFile and ConfigFileExtension properties are not set.", ex); |
| } |
| |
| if (systemConfigFilePath != null) |
| { |
| Uri systemConfigFileUri = new Uri(systemConfigFilePath); |
| |
| // Use the default .config file for the AppDomain |
| fullPath2ConfigFile = systemConfigFileUri; |
| } |
| } |
| else |
| { |
| // Force the extension to start with a '.' |
| if (m_configFileExtension[0] != '.') |
| { |
| m_configFileExtension = "." + m_configFileExtension; |
| } |
| |
| string systemConfigFilePath = null; |
| try |
| { |
| systemConfigFilePath = SystemInfo.ConfigurationFileLocation; |
| } |
| catch(Exception ex) |
| { |
| LogLog.Error(declaringType, "XmlConfiguratorAttribute: Exception getting ConfigurationFileLocation. Must be able to resolve ConfigurationFileLocation when the ConfigFile property are not set.", ex); |
| } |
| |
| if (systemConfigFilePath != null) |
| { |
| UriBuilder builder = new UriBuilder(new Uri(systemConfigFilePath)); |
| |
| // Remove the current extension from the systemConfigFileUri path |
| string path = builder.Path; |
| int startOfExtension = path.LastIndexOf("."); |
| if (startOfExtension >= 0) |
| { |
| path = path.Substring(0, startOfExtension); |
| } |
| path += m_configFileExtension; |
| |
| builder.Path = path; |
| fullPath2ConfigFile = builder.Uri; |
| } |
| } |
| } |
| else |
| { |
| string applicationBaseDirectory = null; |
| try |
| { |
| applicationBaseDirectory = SystemInfo.ApplicationBaseDirectory; |
| } |
| catch(Exception ex) |
| { |
| LogLog.Warn(declaringType, "Exception getting ApplicationBaseDirectory. ConfigFile property path ["+m_configFile+"] will be treated as an absolute URI.", ex); |
| } |
| |
| if (applicationBaseDirectory != null) |
| { |
| // Just the base dir + the config file |
| fullPath2ConfigFile = new Uri(new Uri(applicationBaseDirectory), m_configFile); |
| } |
| else |
| { |
| fullPath2ConfigFile = new Uri(m_configFile); |
| } |
| } |
| |
| if (fullPath2ConfigFile != null) |
| { |
| if (fullPath2ConfigFile.IsFile) |
| { |
| // The m_configFile could be an absolute local path, therefore we have to be |
| // prepared to switch back to using FileInfos here |
| ConfigureFromFile(targetRepository, new FileInfo(fullPath2ConfigFile.LocalPath)); |
| } |
| else |
| { |
| if (m_configureAndWatch) |
| { |
| LogLog.Warn(declaringType, "XmlConfiguratorAttribute: Unable to watch config file loaded from a URI"); |
| } |
| XmlConfigurator.Configure(targetRepository, fullPath2ConfigFile); |
| } |
| } |
| } |
| |
| #region Private Instance Fields |
| |
| private string m_configFile = null; |
| private string m_configFileExtension = null; |
| private bool m_configureAndWatch = false; |
| |
| #endregion Private Instance Fields |
| |
| #region Private Static Fields |
| |
| /// <summary> |
| /// The fully qualified type of the XmlConfiguratorAttribute class. |
| /// </summary> |
| /// <remarks> |
| /// Used by the internal logger to record the Type of the |
| /// log message. |
| /// </remarks> |
| private readonly static Type declaringType = typeof(XmlConfiguratorAttribute); |
| |
| #endregion Private Static Fields |
| } |
| } |
| |
| #endif // !NETCF |