/*
* 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.logging.log4j.core;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.apache.logging.log4j.core.config.ConfigurationListener;
import org.apache.logging.log4j.core.config.DefaultConfiguration;
import org.apache.logging.log4j.core.config.NullConfiguration;
import org.apache.logging.log4j.core.config.Reconfigurable;
import org.apache.logging.log4j.status.StatusLogger;
import java.io.File;
import java.net.URI;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* The LoggerContext is the anchor for the logging system. It maintains a list of all the loggers requested by
* applications and a reference to the Configuration. The Configuration will contain the configured loggers, appenders,
* filters, etc and will be atomically updated whenever a reconfigure occurs.
*/
public class LoggerContext implements org.apache.logging.log4j.spi.LoggerContext, ConfigurationListener, LifeCycle {
private static final StatusLogger logger = StatusLogger.getLogger();
private final ConcurrentMap<String, Logger> loggers = new ConcurrentHashMap<String, Logger>();
/**
* The Configuration is volatile to guarantee that initialization of the Configuration has completed before
* the reference is updated.
*/
private volatile Configuration config = new DefaultConfiguration();
private Object externalContext;
private final String name;
private final URI configLocation;
/**
* Status of the LoggerContext.
*/
public enum Status {
/** Initialized but not yet started. */
INITIALIZED,
/** In the process of starting. */
STARTING,
/** Is active. */
STARTED,
/** Shutdown is in progress. */
STOPPING,
/** Has shutdown. */
STOPPED
}
private volatile Status status = Status.INITIALIZED;
private final Lock configLock = new ReentrantLock();
/**
* Constructor taking only a name.
* @param name The context name.
*/
public LoggerContext(String name) {
this(name, null, (URI) null);
}
/**
* Constructor taking a name and a reference to an external context.
* @param name The context name.
* @param externalContext The external context.
*/
public LoggerContext(String name, Object externalContext) {
this(name, externalContext, (URI) null);
}
/**
* Constructor taking a name, external context and a configuration URI.
* @param name The context name.
* @param externalContext The external context.
* @param configLocn The location of the configuration as a URI.
*/
public LoggerContext(String name, Object externalContext, URI configLocn) {
this.name = name;
this.externalContext = externalContext;
this.configLocation = configLocn;
}
/**
* Constructor taking a name external context and a configuration location String. The location
* must be resolvable to a File.
* @param name The configuration location.
* @param externalContext The external context.
* @param configLocn The configuration location.
*/
public LoggerContext(String name, Object externalContext, String configLocn) {
this.name = name;
this.externalContext = externalContext;
if (configLocn != null) {
URI uri;
try {
uri = new File(configLocn).toURI();
} catch (Exception ex) {
uri = null;
}
configLocation = uri;
} else {
configLocation = null;
}
}
public void start() {
if (configLock.tryLock()) {
try {
if (status == Status.INITIALIZED) {
status = Status.STARTING;
reconfigure();
status = Status.STARTED;
}
} finally {
configLock.unlock();
}
}
}
public void stop() {
configLock.lock();
try {
status = Status.STOPPING;
updateLoggers(new NullConfiguration());
config.stop();
externalContext = null;
status = Status.STOPPED;
} finally {
configLock.unlock();
}
}
/**
* Gets the name.
*
* @return the name.
*/
public String getName() {
return name;
}
public Status getStatus() {
return status;
}
public boolean isStarted() {
return status == Status.STARTED;
}
/**
* Set the external context.
* @param context The external context.
*/
public void setExternalContext(Object context) {
this.externalContext = context;
}
/**
* Returns the external context.
* @return The external context.
*/
public Object getExternalContext() {
return this.externalContext;
}
/**
* Obtain a Logger from the Context.
* @param name The name of the Logger to return.
* @return The Logger.
*/
public Logger getLogger(String name) {
Logger logger = loggers.get(name);
if (logger != null) {
return logger;
}
logger = newInstance(this, name);
Logger prev = loggers.putIfAbsent(name, logger);
return prev == null ? logger : prev;
}
/**
* Determine if the specified Logger exists.
* @param name The Logger name to search for.
* @return True if the Logger exists, false otherwise.
*/
public boolean hasLogger(String name) {
return loggers.containsKey(name);
}
/**
* Returns the current Configuration. The Configuration will be replaced when a reconfigure occurs.
* @return The Configuration.
*/
public Configuration getConfiguration() {
return config;
}
/**
* Add a Filter to the Configuration. Filters that are added through the API will be lost
* when a reconfigure occurs.
* @param filter The Filter to add.
*/
public void addFilter(Filter filter) {
config.addFilter(filter);
}
/**
* Removes a Filter from the current Configuration.
* @param filter The Filter to remove.
*/
public void removeFiler(Filter filter) {
config.removeFilter(filter);
}
/**
* Set the Configuration to be used.
* @param config The new Configuration.
* @return The previous Configuration.
*/
public synchronized Configuration setConfiguration(Configuration config) {
if (config == null) {
throw new NullPointerException("No Configuration was provided");
}
Configuration prev = this.config;
config.addListener(this);
config.start();
this.config = config;
updateLoggers();
if (prev != null) {
prev.removeListener(this);
prev.stop();
}
return prev;
}
/**
* Reconfigure the context.
*/
public synchronized void reconfigure() {
logger.debug("Reconfiguration started for context " + name);
Configuration instance = ConfigurationFactory.getInstance().getConfiguration(name, configLocation);
setConfiguration(instance);
/*instance.start();
Configuration old = setConfiguration(instance);
updateLoggers();
if (old != null) {
old.stop();
} */
logger.debug("Reconfiguration completed");
}
/**
* Cause all Loggers to be updated against the current Configuration.
*/
public void updateLoggers() {
updateLoggers(this.config);
}
/**
* Cause all Logger to be updated against the specified Configuration.
* @param config The Configuration.
*/
public void updateLoggers(Configuration config) {
for (Logger logger : loggers.values()) {
logger.updateConfiguration(config);
}
}
/**
* Cause a reconfiguration to take place when the underlying configuration file changes.
* @param reconfigurable The Configuration that can be reconfigured.
*/
public synchronized void onChange(Reconfigurable reconfigurable) {
logger.debug("Reconfiguration started for context " + name);
Configuration config = reconfigurable.reconfigure();
if (config != null) {
setConfiguration(config);
logger.debug("Reconfiguration completed");
} else {
logger.debug("Reconfiguration failed");
}
}
private Logger newInstance(LoggerContext ctx, String name) {
return new Logger(ctx, name);
}
}