/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
|
* add the following below this CDDL HEADER, with the fields enclosed
|
* by brackets "[]" replaced with your own identifying information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Portions Copyright 2006-2007 Sun Microsystems, Inc.
|
*/
|
package org.opends.server.loggers;
|
|
|
|
import java.io.PrintWriter;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.StringTokenizer;
|
|
import org.opends.server.api.ErrorLogger;
|
import org.opends.server.config.ConfigEntry;
|
import org.opends.server.types.ErrorLogCategory;
|
import org.opends.server.types.ErrorLogSeverity;
|
import org.opends.server.util.TimeThread;
|
|
|
|
/**
|
* This class defines a Directory Server error logger that will be used only
|
* during startup. It makes it possible for informational, warning, and error
|
* messages to be generated during startup and made available to the user for
|
* things that happen before the configuration can be parsed and all of the
|
* actual error loggers instantiated and registered. This error logger will be
|
* taken out of service once the startup is complete.
|
* <BR><BR>
|
* By default, fatal errors, severe errors, severe warnings, and important
|
* information will be logged. This can be modified on a per-category basis
|
* using a "DS_ERROR_LEVEL" environment variable that should be a
|
* semicolon-delimited list in which each element in that list should contain
|
* the name of the category, an equal sign, and a comma-delimited list of the
|
* severity levels to use for that category.
|
*/
|
public class StartupErrorLogger
|
extends ErrorLogger
|
{
|
/**
|
* The name of the environment variable that may be used to alter the kinds of
|
* messages that get logged with this startup error logger.
|
*/
|
public static final String ENV_VARIABLE_ERROR_LOG_LEVEL = "DS_ERROR_LEVEL";
|
|
|
|
// The hash map that will be used to define specific log severities for the
|
// various categories.
|
private HashMap<ErrorLogCategory,HashSet<ErrorLogSeverity>> definedSeverities;
|
|
// The set of default log severities that will be used if no custom severities
|
// have been defined for the associated category.
|
private HashSet<ErrorLogSeverity> defaultSeverities;
|
|
// The writer that will be used to actually write the messages.
|
private PrintWriter writer;
|
|
|
|
/**
|
* Creates a new instance of this startup error logger. It does not actually
|
* do anything, since all initialization is performed in the
|
* <CODE>initializeErrorLogger</CODE> method.
|
*/
|
public StartupErrorLogger()
|
{
|
super();
|
}
|
|
|
|
/**
|
* Initializes this error logger based on the information in the provided
|
* configuration entry.
|
*
|
* @param configEntry The configuration entry that contains the information
|
* to use to initialize this error logger.
|
*/
|
public void initializeErrorLogger(ConfigEntry configEntry)
|
{
|
writer = new PrintWriter(System.err, true);
|
|
defaultSeverities = new HashSet<ErrorLogSeverity>();
|
defaultSeverities.add(ErrorLogSeverity.FATAL_ERROR);
|
defaultSeverities.add(ErrorLogSeverity.SEVERE_ERROR);
|
defaultSeverities.add(ErrorLogSeverity.SEVERE_WARNING);
|
defaultSeverities.add(ErrorLogSeverity.NOTICE);
|
|
definedSeverities =
|
new HashMap<ErrorLogCategory,HashSet<ErrorLogSeverity>>();
|
|
|
String logLevelInfo = System.getenv(ENV_VARIABLE_ERROR_LOG_LEVEL);
|
if (logLevelInfo != null)
|
{
|
StringTokenizer tokenizer = new StringTokenizer(logLevelInfo, ";");
|
while (tokenizer.hasMoreTokens())
|
{
|
String token = tokenizer.nextToken();
|
int equalPos = token.indexOf('=');
|
if (equalPos < 0)
|
{
|
writer.println("StartupErrorLogger: Token \"" + token +
|
"\" read from environment variable " +
|
ENV_VARIABLE_ERROR_LOG_LEVEL + " does not contain " +
|
"an equal sign to separate the category from the " +
|
"severity list. It will be ignored");
|
continue;
|
}
|
|
String categoryName = token.substring(0, equalPos);
|
ErrorLogCategory category = ErrorLogCategory.getByName(categoryName);
|
if (category == null)
|
{
|
writer.println("StartupErrorLogger: Unknown error log category \"" +
|
categoryName + "\" read from environment variable " +
|
ENV_VARIABLE_ERROR_LOG_LEVEL + " will be ignored.");
|
continue;
|
}
|
|
HashSet<ErrorLogSeverity> severities = new HashSet<ErrorLogSeverity>();
|
StringTokenizer sevTokenizer =
|
new StringTokenizer(token.substring(equalPos+1), ",");
|
while (sevTokenizer.hasMoreElements())
|
{
|
String severityName = sevTokenizer.nextToken();
|
ErrorLogSeverity severity = ErrorLogSeverity.getByName(severityName);
|
if (severity == null)
|
{
|
writer.println("StartupErrorLogger: Unknown error log severity " +
|
"\"" + severityName + "\" read from environment " +
|
"variable " + ENV_VARIABLE_ERROR_LOG_LEVEL +
|
" will be ignored.");
|
continue;
|
}
|
else
|
{
|
severities.add(severity);
|
}
|
}
|
|
definedSeverities.put(category, severities);
|
}
|
}
|
}
|
|
|
|
/**
|
* Closes this error logger and releases any resources it might have held.
|
*/
|
public void closeErrorLogger()
|
{
|
// No action is required, and this logger will remain usable.
|
}
|
|
|
|
/**
|
* Writes a message to the error log using the provided information.
|
*
|
* @param category The category that may be used to determine whether to
|
* actually log this message.
|
* @param severity The severity that may be used to determine whether to
|
* actually log this message.
|
* @param message The message to be logged.
|
* @param errorID The error ID that uniquely identifies the format string
|
* used to generate the provided message.
|
*/
|
public void logError(ErrorLogCategory category, ErrorLogSeverity severity,
|
String message, int errorID)
|
{
|
HashSet<ErrorLogSeverity> severities = definedSeverities.get(category);
|
if (severities == null)
|
{
|
severities = defaultSeverities;
|
}
|
|
if (severities.contains(severity))
|
{
|
StringBuilder logMsg = new StringBuilder();
|
|
logMsg.append('[');
|
logMsg.append(TimeThread.getLocalTime());
|
logMsg.append("] category=");
|
logMsg.append(category.getCategoryName());
|
logMsg.append(" severity=");
|
logMsg.append(severity.getSeverityName());
|
logMsg.append(" id=");
|
logMsg.append(errorID);
|
logMsg.append(" msg=\"");
|
logMsg.append(message);
|
logMsg.append("\"");
|
|
writer.println(logMsg.toString());
|
}
|
}
|
|
|
|
/**
|
* Indicates whether the provided object is equal to this error logger.
|
*
|
* @param o The object for which to make the determination.
|
*
|
* @return <CODE>true</CODE> if the provided object is determined to be equal
|
* to this error logger, or <CODE>false</CODE> if not.
|
*/
|
public boolean equals(Object o)
|
{
|
if (this == o)
|
{
|
return true;
|
}
|
|
if ((o == null) || (! (o instanceof StartupErrorLogger)))
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
|
|
/**
|
* Retrieves the hash code for this error logger.
|
*
|
* @return The hash code for this error logger.
|
*/
|
public int hashCode()
|
{
|
// Just make one up, since there should never be a need to have more than
|
// one instance of this error logger.
|
return 12345;
|
}
|
}
|
