Attachment #21098 for bug #43820

View | Details | Raw Unified | Return to bug 43820
Collapse All | Expand All




/*
 * 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.
 */

package org.apache.log4j.spi;

import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.Level;

/**
 * A mock appender that provides a nice and easy way to verify that logging
 * events passed through a logger end up where they are supposed to go.
 * <p>
 * The basic structure of this class is taken from EasyMock. You tell it to
 * expect some number of events, then set it to "replay", run the test and then
 * call "verify" to see that the expected result occured.
 * <p>
 * This class is written solely for testing the LayeredConfigurator, and may or
 * may not be suitable for other tests.
 *
 * @author Will Sargent
 *
 */
public class MockAppender extends AppenderSkeleton {

  private List expectedEvents = new ArrayList();

  private List actualEvents = new ArrayList();

  private boolean replayMode = false;

  private static MockAppender sSingleton;

  /**
   * Gets the singleton mock appender. This is inelegant, but we need it so that
   * we can get at the appender instance defined in the base-appenders.xml file.
   *
   * @return the mock appender defined.
   */
  public static MockAppender getMockAppender() {
    return sSingleton;
  }

  /**
   * A no-args constructor that initializes the singleton. Probably not
   * thread-safe.
   */
  public MockAppender() {
    sSingleton = this;
  }

  public void expectEvent(LoggingEvent expectedEvent) {
    if (replayMode) {
      throw new IllegalStateException("Cannot expect events in replay mode");
    }

    expectedEvents.add(expectedEvent);
  }

  /**
   * Sets replayMode to false.
   */
  public void replay() {
    replayMode = true;
  }

  /**
   * Resets the lists and sets replayMode to false.
   */
  public void reset() {
    expectedEvents.clear();
    actualEvents.clear();
    replayMode = false;
  }

  public void verify() {
    // Run through the expected events and see if they match the actual events.
    if (!replayMode) {
      throw new IllegalStateException("verify() called before replay()");
    }

    // Check we've got the same number...
    if (actualEvents.size() != expectedEvents.size()) {
      String msg = "Expected " + expectedEvents.size()
          + " events, but received " + actualEvents.size() + ".";
      throw new AssertionError(msg);
    }

    // Only check that the level and message are the same...
    for (int i = 0; i < expectedEvents.size(); i++) {
      LoggingEvent expectedEvent = (LoggingEvent) expectedEvents.get(i);
      LoggingEvent actualEvent = (LoggingEvent) actualEvents.get(i);

      final Level expectedLevel = expectedEvent.getLevel();
      final Level actualLevel = actualEvent.getLevel();
      if (!expectedLevel.equals(actualLevel)) {
        String msg = "Expected " + expectedLevel + ", but was " + actualLevel;
        throw new AssertionError(msg);
      }

      final Object expectedMessage = expectedEvent.getMessage();
      final Object actualMessage = actualEvent.getMessage();
      if (!expectedMessage.equals(actualMessage)) {
        String msg = "Expected " + expectedMessage + ", but was "
            + actualMessage;
        throw new AssertionError(msg);
      }
    }
  }

  protected void append(LoggingEvent event) {
    // Check that we're okay to get events...
    if (!replayMode) {
      throw new IllegalStateException(
          "Event appended before replay() was called");
    }

    // Save this for later.
    actualEvents.add(event);
  }

  public void close() {
    ; // do nothing.
  }

  public boolean requiresLayout() {
    return false;
  }

}




/*
 * 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.
 */

package org.apache.log4j.spi;

import java.net.MalformedURLException;
import java.net.URL;
import java.text.ParseException;

import junit.framework.TestCase;

import org.apache.log4j.Hierarchy;
import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.helpers.Loader;

/**
 * Unit tests for the layered configurator. Most of these have to do with
 * parsing the ${system.property} syntax.
 *
 * @author Will Sargent
 */
public class LayeredConfiguratorTest extends TestCase {
  private static final Object GUARD = new Object();

  LayeredConfigurator configurator;

  LoggerRepository repository = new Hierarchy(new RootLogger(Level.DEBUG));

  protected void setUp() throws Exception {
    super.setUp();
    configurator = new LayeredConfigurator();
  }

  /**
   * Tests that a normal line makes it through parsing.
   */
  public final void testParseLineWithNoParameter() {
    String expected = "http://example.org";
    try {
      String actual = configurator.parseLine(expected);
      assertEquals("Line should have been seen.", expected, actual);
    } catch (ParseException e) {
      fail(e.toString());
    }
  }

  /**
   * Tests that a line with substitution makes it through parsing.
   */
  public final void testParseLineWithParameter() {
    String expected = "http://${my.hostname}.org";
    try {
      String actual = configurator.parseLine(expected);
      assertEquals("Line should have been seen.", expected, actual);
    } catch (ParseException e) {
      fail(e.toString());
    }
  }

  /**
   * Tests that a line with no terminator does NOT make it through parsing.
   */
  public final void testParseLineWithNoParameterTermination() {
    try {
      String url = "http://${my.hostname.org";
      configurator.parseLine(url);
      fail("Should have thrown parse exception");
    } catch (ParseException pe) {
    }
  }

  /**
   * Comments should show up as null through the parser.
   */
  public final void testParseLineWithComment() {
    try {
      String url = "# http://${my.hostname.org";
      String actual = configurator.parseLine(url);
      assertNull("Line should have been null.", actual);
    } catch (ParseException pe) {
      fail(pe.toString());
    }
  }

  /**
   * Tests that a line containing a raw dollar makes it through parsing.
   */
  public final void testParseLineWithDollar() {
    try {
      String url = "http://$my.hostname.org";
      configurator.parseLine(url);
    } catch (ParseException pe) {
      fail("Should not have thrown parse exception");
    }
  }

  /**
   * Tests that parameters are substituted appropriately.
   */
  public final void testSubstituteParameters() {
    // Currently only system properties are substituted.
    System.setProperty("my.hostname", "example");

    String url = "http://${my.hostname}.org";
    String expected = "http://example.org";
    String actual = configurator.substituteParameters(url);

    assertEquals("Parameter should have been substituted", expected, actual);
  }

  /**
   * Tests the layered configurator in the development configuration.  This should
   * run all the way through debug to fatal.
   *
   * @throws MalformedURLException
   */
  public final void testDevelopmentConfiguration() throws MalformedURLException {

    // Run through the log4j configuration using the development settings.
    // The LogManager has all of the initialization logic tied up in a
    // static method, so we have to set things up so that we can switch
    // it out on the fly.

    // Set the property so it will resolve to "dev-loggers.properties"
    System.setProperty("my.environment", "dev");

    URL url = Loader
        .getResource("org/apache/log4j/spi/log4j-config.properties");
    configurator.doConfigure(url, repository);

    // Set up the log manager to have the appropriate repository selector...
    RepositorySelector selector = new DefaultRepositorySelector(repository);

    LogManager.setRepositorySelector(selector, GUARD);

    // Call up a logger, and run it through everything.
    String categoryClass = "com.tersesystems.log4j";
    Logger logger = LogManager.getLogger(categoryClass);

    // Look at the appender and see if we got all the messages we expect.
    MockAppender appender = MockAppender.getMockAppender();
    appender.reset();

    final String debugMessage = "Debug Message";
    final String infoMessage = "Info message";
    final String warnMessage = "Warning message";
    final String errorMessage = "Error Message";
    final String fatalMessage = "Fatal message";

    appender.expectEvent(new LoggingEvent(categoryClass, logger, Level.DEBUG, debugMessage, null));
    appender.expectEvent(new LoggingEvent(categoryClass, logger, Level.INFO, infoMessage, null));
    appender.expectEvent(new LoggingEvent(categoryClass, logger, Level.WARN, warnMessage, null));
    appender.expectEvent(new LoggingEvent(categoryClass, logger, Level.ERROR, errorMessage, null));
    appender.expectEvent(new LoggingEvent(categoryClass, logger, Level.FATAL, fatalMessage, null));

    appender.replay();
    logger.debug(debugMessage);
    logger.info(infoMessage);
    logger.warn(warnMessage);
    logger.error(errorMessage);
    logger.fatal(fatalMessage);
    appender.verify();
  }

  /**
   * Tests the layered configurator in the development configuration.  This should
   * run all the way through debug to fatal.
   *
   * @throws MalformedURLException
   */
  public final void testProductionConfiguration() throws MalformedURLException {

    // Run through the log4j configuration using the development settings.
    // The LogManager has all of the initialization logic tied up in a
    // static method, so we have to set things up so that we can switch
    // it out on the fly.

    // Set the property so it will resolve to "prod-loggers.properties"
    System.setProperty("my.environment", "prod");

    URL url = Loader
        .getResource("org/apache/log4j/spi/log4j-config.properties");
    configurator.doConfigure(url, repository);

    // Set up the log manager to have the appropriate repository selector...
    RepositorySelector selector = new DefaultRepositorySelector(repository);

    LogManager.setRepositorySelector(selector, GUARD);

    // Call up a logger, and run it through everything.
    String categoryClass = "com.tersesystems.log4j";
    Logger logger = LogManager.getLogger(categoryClass);

    // Look at the appender and see if we got all the messages we expect.
    MockAppender appender = MockAppender.getMockAppender();
    appender.reset();

    final String debugMessage = "Debug Message";
    final String infoMessage = "Info message";
    final String warnMessage = "Warning message";
    final String errorMessage = "Error Message";
    final String fatalMessage = "Fatal message";

    // Only expect WARN and above to actually be appended.
    appender.expectEvent(new LoggingEvent(categoryClass, logger, Level.WARN, warnMessage, null));
    appender.expectEvent(new LoggingEvent(categoryClass, logger, Level.ERROR, errorMessage, null));
    appender.expectEvent(new LoggingEvent(categoryClass, logger, Level.FATAL, fatalMessage, null));

    // Play through everything, including the (disabled) debug and info messages.
    appender.replay();
    logger.debug(debugMessage);
    logger.info(infoMessage);
    logger.warn(warnMessage);
    logger.error(errorMessage);
    logger.fatal(fatalMessage);
    appender.verify();
  }
}




/*
 * 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.
 */

package org.apache.log4j.spi;

import java.net.URL;

import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.xml.DOMConfigurator;

import junit.framework.TestCase;

/**
 * Tests the configurator factory.
 *
 * @author Will Sargent
 * @see org.apache.log4j.spi.ConfiguratorFactory
 */
public class ConfiguratorFactoryTest extends TestCase {

  private ConfiguratorFactory configuratorFactory;

  protected void setUp() throws Exception {
    super.setUp();
    configuratorFactory = new ConfiguratorFactory();
  }

  /**
   * Tests adding a fake configurator.
   * @throws IllegalAccessException
   * @throws InstantiationException
   */
  public final void testAddConfigurator() throws InstantiationException, IllegalAccessException {
    configuratorFactory.addConfigurator("yaml", YamlConfigurator.class);
    Configurator actual = configuratorFactory.findConfiguratorByType("yaml");

    assertTrue("Expected yaml configurator here", actual instanceof YamlConfigurator);
  }

  /**
   * Checks that we can get a properties configurator.
   */
  public final void testGetPropertiesConfigurator() {
    Configurator actual = configuratorFactory
        .getConfigurator("log4j.properties");
    assertTrue("Expected a property configurator",
        actual instanceof PropertyConfigurator);
  }

  /**
   * Tests getting the XML configurator.
   */
  public final void testGetDOMConfigurator() {
    Configurator actual = configuratorFactory.getConfigurator("log4j.xml");
    assertTrue("Expected a property configurator",
        actual instanceof DOMConfigurator);
  }

  /**
   * Tests that an exception is thrown if we don't find a configurator.
   */
  public final void testGetMissingConfigurator() {
    try {
      configuratorFactory.getConfigurator("log4j.yaml");
      fail("An illegal state exception should have been thrown");
    } catch (IllegalStateException e) {
    }
  }

  /**
   * A fake YAML configurator to test things out.
   */
  static class YamlConfigurator implements Configurator {

    public void doConfigure(URL url, LoggerRepository repository) {
      ; // do nothing
    }
  }
}

Line 0 Link Here

(-)D:/home/wsargent/javawork/layered-configurator-extra/src/test/resources/org/apache/log4j/spi/prod-loggers.properties (+2 lines)
	1	# Define loggers with production properties
	2	log4j.logger.com.tersesystems.log4j=WARN




<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "http://logging.apache.org/log4j/docs/api/org/apache/log4j/xml/log4j.dtd">

<!--
/*
 * 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.
 */
 -->

<!-- The basic appender that gets used in every situation -->
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

  <!--
    Write all events to the mock appender.
  -->
  <appender name="mock" class="org.apache.log4j.spi.MockAppender">
    <param name="Threshold" value="DEBUG" />
    <layout class="org.apache.log4j.PatternLayout">
      <param name="ConversionPattern" value="%d [%t] %-5p %c - %m%n" />
    </layout>
  </appender>

  <!--
     Tell the root logger that we want a default priority of INFO,
     and we want to log to the console and to the asynchronous appender.
  -->
  <root>
    <priority value="INFO" />
    <appender-ref ref="mock"/>
  </root>

</log4j:configuration>

Line 0 Link Here

(-)D:/home/wsargent/javawork/layered-configurator-extra/src/test/resources/org/apache/log4j/spi/dev-loggers.properties (+2 lines)
	1	# Define loggers with development settings.
	2	log4j.logger.com.tersesystems.log4j=DEBUG

Line 0 Link Here

(-)D:/home/wsargent/javawork/layered-configurator-extra/src/test/resources/org/apache/log4j/spi/log4j-config.properties (+9 lines)
	1	# This file contains the XML and properties files to load, in order.
	2	# It is used by the layered configurator.
	3
	4	# The complicated appenders are rendered in XML.
	5	org/apache/log4j/spi/base-appenders.xml
	6
	7	# The logging levels can be defined in properties, and can use system properties
	8	# as parameters.
	9	org/apache/log4j/spi/${my.environment}-loggers.properties




/*
 * 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.
 */

package org.apache.log4j.spi;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.LogManager;
import org.apache.log4j.helpers.Loader;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.helpers.OptionConverter;

/**
 * This class will go through a properties files with references to DOM or
 * Properties configurator file, and call the appropriate configurator in the
 * order they are defined.
 * <p>
 * This doesn't mean much in theory, so let's explain why this class exists, and
 * give an example.
 * <p>
 * Log4J lacks a way to spread configuration over several files. You have one
 * configuration file, either log4j.properties or log4j.xml, and that's it.
 * <p>
 * In projects where you have several environments to keep track of, you may
 * want to have some loggers set to DEBUG in the development environment, but
 * set to WARN on the production environment. However, you usually want to keep
 * all the appenders and logging infrastructure the same.
 * <p>
 * Because Log4J defines appenders and loggers in the same file, you either have
 * to define several almost identical files with the appropriate changes for the
 * environment, or you have to have an Ant script that goes through and replaces
 * tokens for the appropriate environment.
 * <p>
 * The file syntax for the configurators is simple. Here's an example
 * log4j-config.properties file:
 *
 * <pre>
 * # The complicated appenders are rendered in XML.
 * base-appenders.xml
 *
 * # The logging levels can be defined in properties, and can use system properties
 * # as parameters.
 * ${my.environment}-loggers.properties
 * </pre>
 *
 * <p>
 * The class is called LayeredConfigurator because it's meant to work in layers.
 * The configurators are not reset, so all the settings from the previous
 * configurator will still apply unless you override them.
 * <p>
 * When you define <code>-Dmy.environment=dev</code>, then your development
 * settings will be loaded. When you define <code>-Dmy.environment=prod</code>,
 * then your production settings will be loaded. Either way, your binary
 * distribution is exactly the same, with only the environment specific
 * properties
 * <p>
 * To enable this class, you must start the JVM with the following system
 * properties:
 *
 * <pre>
 * -Dlog4j.configuratorClass=com.tersesystems.log4j.LayeredConfigurator
 * -Dlog4j.configuration=log4j-config.properties
 * </pre>
 *
 * <p>
 * This class has been written using Java 1.3 syntax, lots of internal methods,
 * and with the internal methods protected, so that it can be subclassed and
 * modified as needed.
 *
 * @author Will Sargent
 *
 * @see org.apache.log4j.spi.Configurator
 * @see org.apache.log4j.spi.ConfiguratorFactory
 */
public class LayeredConfigurator implements Configurator {

  protected static final String PARAMETER_START = "${";

  protected static final String PARAMETER_END = "}";

  protected static final String COMMENT = "#";

  /**
   * A static version of {@link #doConfigure(URL, LoggerRepository)}.
   */
  public static void configure(URL url) {
    new LayeredConfigurator()
        .doConfigure(url, LogManager.getLoggerRepository());
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.log4j.spi.Configurator#doConfigure(java.net.URL,
   *      org.apache.log4j.spi.LoggerRepository)
   */
  public void doConfigure(URL configURL, LoggerRepository repository) {
    LogLog.debug("Reading configuration from URL " + configURL);

    if (configURL == null) {
      throw new IllegalArgumentException("null configURL");
    }

    if (repository == null) {
      throw new IllegalArgumentException("null repository");
    }

    InputStream istream = null;
    try {
      istream = configURL.openStream();
      doConfigure(istream, repository);
    } catch (Exception e) {
      LogLog.error("Could not read configuration file from URL [" + configURL
          + "].", e);
      LogLog.error("Ignoring configuration file [" + configURL + "].");
      return;
    }
  }

  /**
   * Converts the input stream into a reader and then passes to the reader
   * method.
   *
   * @param istream
   * @param repository
   * @throws IOException
   * @throws ParseException
   */
  protected void doConfigure(InputStream istream, LoggerRepository repository)
      throws IOException, ParseException {
    if (istream == null) {
      return;
    }

    BufferedReader reader = new BufferedReader(new InputStreamReader(istream));
    List configurationReferences = parseConfigurationList(reader);

    LogLog.debug("list = " + configurationReferences);

    doConfigure(configurationReferences, repository);
  }

  /**
   * Parses the lines of text from the reader. This method deals with the
   * opening and closing of IO handles.
   *
   * @param reader
   *                the reader to pull in the file.
   * @return a list containing the parsed strings.
   */
  protected List parseConfigurationList(BufferedReader reader)
      throws IOException, ParseException {
    if (reader == null) {
      throw new IllegalArgumentException("null reader");
    }

    List configurationList = new ArrayList();
    String line = null;
    try {
      while ((line = reader.readLine()) != null) {
        String parsedLine = parseLine(line);
        if (parsedLine != null) {
          configurationList.add(parsedLine);
        }
      }
    } finally {
      reader.close();
    }
    return configurationList;
  }

  /**
   * See if the line starts with #. If it does, then it's a comment.
   *
   * We don't assume that anything after # can be a comment, because there's
   * always the possibility that someone has factored in a URL with a bookmark.
   *
   * This method does not do any substitution of variables; we want to make sure
   * we can parse everything before we move any further.
   *
   * @throws ParseException
   *                 if the line cannot be parsed.
   */
  protected String parseLine(String rawLine) throws ParseException {
    // If nothing, then nothing.
    if (rawLine == null) {
      return null;
    }

    String line = rawLine;
    String trimmedLine = line.trim();

    // Ignore a completely empty line.
    if (trimmedLine.length() == 0) // NOPMD
    {
      return null;
    }

    // If the line contains nothing but whitespace and then "#" then we
    // consider it a comment.
    if (trimmedLine.startsWith(COMMENT)) {
      return null;
    }

    // If the line contains "${" but not "}" then throw an exception.
    int fromIndex = line.indexOf(PARAMETER_START);
    if (fromIndex != -1) {
      int endIndex = line.indexOf(PARAMETER_END, fromIndex + 1);
      if (endIndex == -1) {
        throw new ParseException("Cannot parse line: " + line, fromIndex);
      }

      // For simplicity's sake, let's not nest.
      int newStartIndex = line.indexOf(PARAMETER_START, fromIndex + 1);
      if (newStartIndex != -1 && newStartIndex < endIndex) {
        throw new ParseException("Cannot parse line: " + line, newStartIndex);
      }
    }

    return rawLine;
  }

  /**
   * Returns a configurator factory.
   *
   * @return a new configurator factory.
   */
  protected ConfiguratorFactory getConfiguratorFactory() {
    return new ConfiguratorFactory();
  }

  /**
   * Configures a list of configuration references, substituting parameters as
   * needed.
   *
   * @param configurationReferences
   * @param repository
   */
  protected void doConfigure(List configurationReferences,
      LoggerRepository repository) {
    // Run through any substitutions of parameters. Parameters are defined
    // in the syntax ${parameter}. They must resolve to strings.
    List parsedReferences = substituteListParameters(configurationReferences);

    ConfiguratorFactory configuratorFactory = getConfiguratorFactory();

    // Go through the list of references, using a configurator factory to
    // pull out the appropriate configurator.
    for (Iterator iter = parsedReferences.iterator(); iter.hasNext();) {
      String reference = (String) iter.next();
      Configurator c = configuratorFactory.getConfigurator(reference);

      URL url;
      try {
        url = new URL(reference);
      } catch (MalformedURLException ex) {
        // so, resource is not a URL:
        // attempt to get the resource from the class path
        url = Loader.getResource(reference);
      }

      // The internal reference doesn't resolve to anything either...
      if (url == null) {
        String msg = "The internal reference " + reference + " does not resolve to a resource";
        throw new IllegalArgumentException(msg);
      }

      // Tell the configurator to go do its stuff.
      c.doConfigure(url, repository);
    }
  }

  /**
   * Goes through a list of configuration references that may contain
   * ${parameter} in the string, and resolves the parameters.
   *
   * @param configurationReferences
   *                a list of configuration references with parameters.
   * @return a list of configuration files with the parameters replaced by text.
   */
  protected List substituteListParameters(List configurationReferences) {
    List resolvedList = new ArrayList();
    for (Iterator iter = configurationReferences.iterator(); iter.hasNext();) {
      String configRef = (String) iter.next();
      String resolvedRef = substituteParameters(configRef);
      resolvedList.add(resolvedRef);
    }

    return resolvedList;
  }

  /**
   * Substitute all the parameters in a reference.
   *
   * @param configRef
   * @return a reference with all the parameters replaced by text.
   */
  protected String substituteParameters(String configRef) {
    // If I assume Java 1.4 or 1.5, this could be much easier. But let's do
    // it the old fashioned way.

    // state can be 1 {dollar), 2 (parsing), or 0 (raw).
    // We assume that the string cannot be malformed here.
    int state = 0;
    StringBuffer line = new StringBuffer();
    StringBuffer parameterName = new StringBuffer();
    byte[] characters = configRef.getBytes();
    for (int i = 0; i < characters.length; i++) {
      char ch = (char) characters[i];
      switch (ch) {
      case '$':
        state = 1;
        break;

      case '{':
        if (state == 1) {
          state = 2;
          parameterName.setLength(0); // clear the param name.
        }
        break;

      case '}':
        state = 0;
        // look up the parameter name, and append to the line.
        String parameterValue = substituteParameter(parameterName.toString());
        line.append(parameterValue);
        break;

      default:
        if (state == 0) // a raw char
        {
          line.append(ch);
        } else if (state == 1) // just a raw dollar
        {
          state = 0;
          line.append(ch);
        } else if (state == 2) // this is a parameter name
        {
          parameterName.append(ch);
        }
      }
    }

    return line.toString();
  }

  /**
   * Substitutes a single parameter. A null value will be replaced by the empty
   * string.
   *
   * @param parameterName
   *                the parameter's name.
   * @return the parameter value.
   */
  protected String substituteParameter(String parameterName) {
    LogLog.debug("substituteParameter: found " + parameterName);

    String parameterValue = OptionConverter
        .getSystemProperty(parameterName, "");
    LogLog.debug("substituteParameter: replacing " + parameterName + " with "
        + parameterValue);
    return parameterValue;
  }
}




/*
 * 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.
 */

package org.apache.log4j.spi;

import java.util.HashMap;
import java.util.Map;

import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.spi.Configurator;
import org.apache.log4j.xml.DOMConfigurator;

/**
 * This is a simple class to abstract the instantation of a configurator.
 * <p>
 * The factory contains a map of types, along with the configurator objects that
 * will be used for those types. The factory is configured for references ending
 * in ".properties" or ".xml", but other configurators can be added as need be.
 * <p>
 * This class may or may not be thread-safe. No attempt has been made to ensure
 * thread-safety.
 *
 * @author Will Sargent
 * @see org.apache.log4j.PropertyConfigurator
 * @see org.apache.log4j.xml.DOMConfigurator
 */
public class ConfiguratorFactory {

  /** The string that will return a Properties Configurator. */
  public static final String PROPERTIES_TYPE = "properties";

  /** The string that will return a DOM configurator. */
  public static final String XML_TYPE = "xml";

  /**
   * A map of types to configurator instances.
   */
  private Map configuratorMap = new HashMap();

  /**
   * A default constructor that will call the initialize() method.
   */
  public ConfiguratorFactory() {
    initialize();
  }

  /**
   * Initializes the configurator map.
   */
  protected void initialize() {
    addConfigurator(PROPERTIES_TYPE, PropertyConfigurator.class);
    addConfigurator(XML_TYPE, DOMConfigurator.class);
  }

  /**
   * Adds a configurator class with the given type.
   *
   * @param type
   *          the type of configurator to use.
   * @param configuratorClass
   *          the configurator class. Must take a no-args constructor.
   */
  public void addConfigurator(String type, Class configuratorClass) {
    if (type == null) {
      throw new IllegalArgumentException("Null type");
    }

    if (configuratorClass == null) {
      throw new IllegalArgumentException("Null configurator");
    }

    configuratorMap.put(type, configuratorClass);
  }

  /**
   * Given a reference to a configurator, returns the appropriate configurator
   * instance. For example, if the reference is "log4j.properties", then it has
   * the "properties" type and a PropertyConfigurator is used.
   *
   * @param reference
   *          a reference to a name (typically a file or classpath reference)
   * @return the appropriate Configurator object for the reference.
   * @throw IllegalStateException if no configurator is found, or the
   *        configurator could not be instantiated.
   */
  public Configurator getConfigurator(String reference) {
    if (reference == null) {
      throw new IllegalArgumentException("Null reference found.");
    }

    // Find the last index of dot. We'll use this as a lookup table.
    int lastIndex = reference.lastIndexOf('.');

    // No dot found.
    if (lastIndex == -1) {
      throw new IllegalArgumentException("No dot suffix found");
    }

    String suffix = reference.substring(lastIndex + 1);
    if (suffix.length() == 0) {
      throw new IllegalArgumentException("Null or empty suffix found.");
    }

    // Get the configurator.
    try {
      Configurator c = findConfiguratorByType(suffix);
      return c;
    } catch (InstantiationException ie) {
      String msg = "Could not instantiate configurator from reference " + reference;
      throw new IllegalStateException(msg, ie);
    } catch (IllegalAccessException iae) {
      String msg = "Could not instantiate configurator from reference " + reference;
      throw new IllegalStateException(msg, iae);
    }
  }

  /**
   * Instantiates a new configurator given the appropriate type.
   *
   * @param type
   *          the type of configurator to use.
   * @return the configurator object for that type.
   * @throws IllegalAccessException
   * @throws InstantiationException
   * @throw IllegalStateException if no configurator is found for the reference.
   */
  protected Configurator findConfiguratorByType(String type)
      throws InstantiationException, IllegalAccessException {
    Class configuratorClass = (Class) configuratorMap.get(type);
    if (configuratorClass == null) {
      throw new IllegalStateException("No configurator class found for type "
          + type);
    }
    return (Configurator) configuratorClass.newInstance();
  }
}

Return to bug 43820

Line 0 Link Here

(-)D:/home/wsargent/javawork/layered-configurator-extra/src/test/java/org/apache/log4j/spi/MockAppender.java (+146 lines)
		1	/*
		2	* Licensed to the Apache Software Foundation (ASF) under one or more
		3	* contributor license agreements. See the NOTICE file distributed with
		4	* this work for additional information regarding copyright ownership.
		5	* The ASF licenses this file to You under the Apache License, Version 2.0
		6	* (the "License"); you may not use this file except in compliance with
		7	* the License. You may obtain a copy of the License at
		8	*
		9	* http://www.apache.org/licenses/LICENSE-2.0
		10	*
		11	* Unless required by applicable law or agreed to in writing, software
		12	* distributed under the License is distributed on an "AS IS" BASIS,
		13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		14	* See the License for the specific language governing permissions and
		15	* limitations under the License.
		16	*/
		17
		18	package org.apache.log4j.spi;
		19
		20	import java.util.ArrayList;
		21	import java.util.List;
		22
		23	import org.apache.log4j.AppenderSkeleton;
		24	import org.apache.log4j.Level;
		25
		26	/**
		27	* A mock appender that provides a nice and easy way to verify that logging
		28	* events passed through a logger end up where they are supposed to go.
		29	* <p>
		30	* The basic structure of this class is taken from EasyMock. You tell it to
		31	* expect some number of events, then set it to "replay", run the test and then
		32	* call "verify" to see that the expected result occured.
		33	* <p>
		34	* This class is written solely for testing the LayeredConfigurator, and may or
		35	* may not be suitable for other tests.
		36	*
		37	* @author Will Sargent
		38	*
		39	*/
		40	public class MockAppender extends AppenderSkeleton {
		41
		42	private List expectedEvents = new ArrayList();
		43
		44	private List actualEvents = new ArrayList();
		45
		46	private boolean replayMode = false;
		47
		48	private static MockAppender sSingleton;
		49
		50	/**
		51	* Gets the singleton mock appender. This is inelegant, but we need it so that
		52	* we can get at the appender instance defined in the base-appenders.xml file.
		53	*
		54	* @return the mock appender defined.
		55	*/
		56	public static MockAppender getMockAppender() {
		57	return sSingleton;
		58	}
		59
		60	/**
		61	* A no-args constructor that initializes the singleton. Probably not
		62	* thread-safe.
		63	*/
		64	public MockAppender() {
65	sSingleton = this;
66	}
67
68	public void expectEvent(LoggingEvent expectedEvent) {
69	if (replayMode) {
70	throw new IllegalStateException("Cannot expect events in replay mode");
71	}
72
73	expectedEvents.add(expectedEvent);
74	}
75
76	/**
77	* Sets replayMode to false.
78	*/
79	public void replay() {
80	replayMode = true;
81	}
82
83	/**
84	* Resets the lists and sets replayMode to false.
85	*/
86	public void reset() {
87	expectedEvents.clear();
88	actualEvents.clear();
89	replayMode = false;
90	}
91
92	public void verify() {
93	// Run through the expected events and see if they match the actual events.
94	if (!replayMode) {
95	throw new IllegalStateException("verify() called before replay()");
96	}
97
98	// Check we've got the same number...
99	if (actualEvents.size() != expectedEvents.size()) {
100	String msg = "Expected " + expectedEvents.size()
101	+ " events, but received " + actualEvents.size() + ".";
102	throw new AssertionError(msg);
103	}
104
105	// Only check that the level and message are the same...
106	for (int i = 0; i < expectedEvents.size(); i++) {
107	LoggingEvent expectedEvent = (LoggingEvent) expectedEvents.get(i);
108	LoggingEvent actualEvent = (LoggingEvent) actualEvents.get(i);
109
110	final Level expectedLevel = expectedEvent.getLevel();
111	final Level actualLevel = actualEvent.getLevel();
112	if (!expectedLevel.equals(actualLevel)) {
113	String msg = "Expected " + expectedLevel + ", but was " + actualLevel;
114	throw new AssertionError(msg);
115	}
116
117	final Object expectedMessage = expectedEvent.getMessage();
118	final Object actualMessage = actualEvent.getMessage();
119	if (!expectedMessage.equals(actualMessage)) {
120	String msg = "Expected " + expectedMessage + ", but was "
121	+ actualMessage;
122	throw new AssertionError(msg);
123	}
124	}
125	}
126
127	protected void append(LoggingEvent event) {
128	// Check that we're okay to get events...
129	if (!replayMode) {
130	throw new IllegalStateException(
131	"Event appended before replay() was called");
132	}
133
134	// Save this for later.
135	actualEvents.add(event);
136	}
137
138	public void close() {
139	; // do nothing.
140	}
141
142	public boolean requiresLayout() {
143	return false;
144	}
145
146	}

Line 0 Link Here

(-)D:/home/wsargent/javawork/layered-configurator-extra/src/test/java/org/apache/log4j/spi/ConfiguratorFactoryTest.java (+93 lines)
		1	/*
		2	* Licensed to the Apache Software Foundation (ASF) under one or more
		3	* contributor license agreements. See the NOTICE file distributed with
		4	* this work for additional information regarding copyright ownership.
		5	* The ASF licenses this file to You under the Apache License, Version 2.0
		6	* (the "License"); you may not use this file except in compliance with
		7	* the License. You may obtain a copy of the License at
		8	*
		9	* http://www.apache.org/licenses/LICENSE-2.0
		10	*
		11	* Unless required by applicable law or agreed to in writing, software
		12	* distributed under the License is distributed on an "AS IS" BASIS,
		13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		14	* See the License for the specific language governing permissions and
		15	* limitations under the License.
		16	*/
		17
		18	package org.apache.log4j.spi;
		19
		20	import java.net.URL;
		21
		22	import org.apache.log4j.PropertyConfigurator;
		23	import org.apache.log4j.xml.DOMConfigurator;
		24
		25	import junit.framework.TestCase;
		26
		27	/**
		28	* Tests the configurator factory.
		29	*
		30	* @author Will Sargent
		31	* @see org.apache.log4j.spi.ConfiguratorFactory
		32	*/
		33	public class ConfiguratorFactoryTest extends TestCase {
		34
		35	private ConfiguratorFactory configuratorFactory;
		36
		37	protected void setUp() throws Exception {
		38	super.setUp();
		39	configuratorFactory = new ConfiguratorFactory();
		40	}
		41
		42	/**
		43	* Tests adding a fake configurator.
		44	* @throws IllegalAccessException
		45	* @throws InstantiationException
		46	*/
		47	public final void testAddConfigurator() throws InstantiationException, IllegalAccessException {
		48	configuratorFactory.addConfigurator("yaml", YamlConfigurator.class);
		49	Configurator actual = configuratorFactory.findConfiguratorByType("yaml");
		50
		51	assertTrue("Expected yaml configurator here", actual instanceof YamlConfigurator);
		52	}
		53
		54	/**
		55	* Checks that we can get a properties configurator.
		56	*/
		57	public final void testGetPropertiesConfigurator() {
		58	Configurator actual = configuratorFactory
		59	.getConfigurator("log4j.properties");
		60	assertTrue("Expected a property configurator",
		61	actual instanceof PropertyConfigurator);
		62	}
		63
		64	/**
65	* Tests getting the XML configurator.
66	*/
67	public final void testGetDOMConfigurator() {
68	Configurator actual = configuratorFactory.getConfigurator("log4j.xml");
69	assertTrue("Expected a property configurator",
70	actual instanceof DOMConfigurator);
71	}
72
73	/**
74	* Tests that an exception is thrown if we don't find a configurator.
75	*/
76	public final void testGetMissingConfigurator() {
77	try {
78	configuratorFactory.getConfigurator("log4j.yaml");
79	fail("An illegal state exception should have been thrown");
80	} catch (IllegalStateException e) {
81	}
82	}
83
84	/**
85	* A fake YAML configurator to test things out.
86	*/
87	static class YamlConfigurator implements Configurator {
88
89	public void doConfigure(URL url, LoggerRepository repository) {
90	; // do nothing
91	}
92	}
93	}

Line 0 Link Here

(-)D:/home/wsargent/javawork/layered-configurator-extra/src/main/java/org/apache/log4j/spi/ConfiguratorFactory.java (+150 lines)
		1	/*
		2	* Licensed to the Apache Software Foundation (ASF) under one or more
		3	* contributor license agreements. See the NOTICE file distributed with
		4	* this work for additional information regarding copyright ownership.
		5	* The ASF licenses this file to You under the Apache License, Version 2.0
		6	* (the "License"); you may not use this file except in compliance with
		7	* the License. You may obtain a copy of the License at
		8	*
		9	* http://www.apache.org/licenses/LICENSE-2.0
		10	*
		11	* Unless required by applicable law or agreed to in writing, software
		12	* distributed under the License is distributed on an "AS IS" BASIS,
		13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		14	* See the License for the specific language governing permissions and
		15	* limitations under the License.
		16	*/
		17
		18	package org.apache.log4j.spi;
		19
		20	import java.util.HashMap;
		21	import java.util.Map;
		22
		23	import org.apache.log4j.PropertyConfigurator;
		24	import org.apache.log4j.spi.Configurator;
		25	import org.apache.log4j.xml.DOMConfigurator;
		26
		27	/**
		28	* This is a simple class to abstract the instantation of a configurator.
		29	* <p>
		30	* The factory contains a map of types, along with the configurator objects that
		31	* will be used for those types. The factory is configured for references ending
		32	* in ".properties" or ".xml", but other configurators can be added as need be.
		33	* <p>
		34	* This class may or may not be thread-safe. No attempt has been made to ensure
		35	* thread-safety.
		36	*
		37	* @author Will Sargent
		38	* @see org.apache.log4j.PropertyConfigurator
		39	* @see org.apache.log4j.xml.DOMConfigurator
		40	*/
		41	public class ConfiguratorFactory {
		42
		43	/** The string that will return a Properties Configurator. */
		44	public static final String PROPERTIES_TYPE = "properties";
		45
		46	/** The string that will return a DOM configurator. */
		47	public static final String XML_TYPE = "xml";
		48
		49	/**
		50	* A map of types to configurator instances.
		51	*/
		52	private Map configuratorMap = new HashMap();
		53
		54	/**
		55	* A default constructor that will call the initialize() method.
		56	*/
		57	public ConfiguratorFactory() {
		58	initialize();
		59	}
		60
		61	/**
		62	* Initializes the configurator map.
		63	*/
		64	protected void initialize() {
65	addConfigurator(PROPERTIES_TYPE, PropertyConfigurator.class);
66	addConfigurator(XML_TYPE, DOMConfigurator.class);
67	}
68
69	/**
70	* Adds a configurator class with the given type.
71	*
72	* @param type
73	* the type of configurator to use.
74	* @param configuratorClass
75	* the configurator class. Must take a no-args constructor.
76	*/
77	public void addConfigurator(String type, Class configuratorClass) {
78	if (type == null) {
79	throw new IllegalArgumentException("Null type");
80	}
81
82	if (configuratorClass == null) {
83	throw new IllegalArgumentException("Null configurator");
84	}
85
86	configuratorMap.put(type, configuratorClass);
87	}
88
89	/**
90	* Given a reference to a configurator, returns the appropriate configurator
91	* instance. For example, if the reference is "log4j.properties", then it has
92	* the "properties" type and a PropertyConfigurator is used.
93	*
94	* @param reference
95	* a reference to a name (typically a file or classpath reference)
96	* @return the appropriate Configurator object for the reference.
97	* @throw IllegalStateException if no configurator is found, or the
98	* configurator could not be instantiated.
99	*/
100	public Configurator getConfigurator(String reference) {
101	if (reference == null) {
102	throw new IllegalArgumentException("Null reference found.");
103	}
104
105	// Find the last index of dot. We'll use this as a lookup table.
106	int lastIndex = reference.lastIndexOf('.');
107
108	// No dot found.
109	if (lastIndex == -1) {
110	throw new IllegalArgumentException("No dot suffix found");
111	}
112
113	String suffix = reference.substring(lastIndex + 1);
114	if (suffix.length() == 0) {
115	throw new IllegalArgumentException("Null or empty suffix found.");
116	}
117
118	// Get the configurator.
119	try {
120	Configurator c = findConfiguratorByType(suffix);
121	return c;
122	} catch (InstantiationException ie) {
123	String msg = "Could not instantiate configurator from reference " + reference;
124	throw new IllegalStateException(msg, ie);
125	} catch (IllegalAccessException iae) {
126	String msg = "Could not instantiate configurator from reference " + reference;
127	throw new IllegalStateException(msg, iae);
128	}
129	}
130
131	/**
132	* Instantiates a new configurator given the appropriate type.
133	*
134	* @param type
135	* the type of configurator to use.
136	* @return the configurator object for that type.
137	* @throws IllegalAccessException
138	* @throws InstantiationException
139	* @throw IllegalStateException if no configurator is found for the reference.
140	*/
141	protected Configurator findConfiguratorByType(String type)
142	throws InstantiationException, IllegalAccessException {
143	Class configuratorClass = (Class) configuratorMap.get(type);
144	if (configuratorClass == null) {
145	throw new IllegalStateException("No configurator class found for type "
146	+ type);
147	}
148	return (Configurator) configuratorClass.newInstance();
149	}
150	}

Line 0 Link Here

(-)D:/home/wsargent/javawork/layered-configurator-extra/src/test/resources/org/apache/log4j/spi/base-appenders.xml (+45 lines)
	1	<?xml version="1.0" encoding="UTF-8" ?>
	2	<!DOCTYPE log4j:configuration SYSTEM "http://logging.apache.org/log4j/docs/api/org/apache/log4j/xml/log4j.dtd">
	3
	4	<!--
	5	/*
	6	* Licensed to the Apache Software Foundation (ASF) under one or more
	7	* contributor license agreements. See the NOTICE file distributed with
	8	* this work for additional information regarding copyright ownership.
	9	* The ASF licenses this file to You under the Apache License, Version 2.0
	10	* (the "License"); you may not use this file except in compliance with
	11	* the License. You may obtain a copy of the License at
	12	*
	13	* http://www.apache.org/licenses/LICENSE-2.0
	14	*
	15	* Unless required by applicable law or agreed to in writing, software
	16	* distributed under the License is distributed on an "AS IS" BASIS,
	17	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	18	* See the License for the specific language governing permissions and
	19	* limitations under the License.
	20	*/
	21	-->
	22
	23	<!-- The basic appender that gets used in every situation -->
	24	<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
	25
	26	<!--
	27	Write all events to the mock appender.
	28	-->
	29	<appender name="mock" class="org.apache.log4j.spi.MockAppender">
	30	<param name="Threshold" value="DEBUG" />
	31	<layout class="org.apache.log4j.PatternLayout">
	32	<param name="ConversionPattern" value="%d [%t] %-5p %c - %m%n" />
	33	</layout>
	34	</appender>
	35
	36	<!--
	37	Tell the root logger that we want a default priority of INFO,
	38	and we want to log to the console and to the asynchronous appender.
	39	-->
	40	<root>
	41	<priority value="INFO" />
	42	<appender-ref ref="mock"/>
	43	</root>
	44
	45	</log4j:configuration>