/*
|
* 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 org.opends.server.api.DirectoryThread;
|
import org.opends.server.api.ServerShutdownListener;
|
import org.opends.server.core.DirectoryServer;
|
import org.opends.server.types.DebugLogLevel;
|
import org.opends.server.config.ConfigAttribute;
|
import org.opends.server.types.DirectoryException;
|
import org.opends.server.types.InvokableMethod;
|
import org.opends.server.types.ResultCode;
|
|
import static org.opends.server.loggers.debug.DebugLogger.debugEnabled;
|
import static org.opends.server.loggers.debug.DebugLogger.debugVerbose;
|
import static org.opends.server.loggers.debug.DebugLogger.debugCaught;
|
import static org.opends.server.messages.ConfigMessages.*;
|
import static org.opends.server.messages.MessageHandler.getMessage;
|
|
import java.io.*;
|
import java.util.concurrent.CopyOnWriteArrayList;
|
import java.util.ArrayList;
|
|
/**
|
* A MultiFileTextWriter is a specialized TextWriter which supports publishing
|
* log records to a set of files. MultiFileWriters write to one file in the
|
* set at a time, switching files as is dictated by a specified rotation
|
* and retention policies.
|
*
|
* When a switch is required, the writer closes the current file and opens a
|
* new one named in accordance with a specified FileNamingPolicy.
|
*/
|
public class MultifileTextWriter extends TextWriter
|
implements ServerShutdownListener
|
{
|
private static final String UTF8_ENCODING= "UTF-8";
|
private static final int BUFFER_SIZE= 65536;
|
|
private CopyOnWriteArrayList<RotationPolicy> rotationPolicies;
|
private CopyOnWriteArrayList<RetentionPolicy> retentionPolicies;
|
private FileNamingPolicy namingPolicy;
|
//TODO: Implement actions.
|
private ArrayList<ActionType> actions;
|
|
private String name;
|
private String encoding;
|
private int bufferSize;
|
private boolean autoFlush;
|
private boolean append;
|
private int interval;
|
private boolean stopRequested;
|
|
private Thread rotaterThread;
|
|
/**
|
* Get the writer for the initial log file and initialize the
|
* rotation policy.
|
* @param naming - the file naming policy in use
|
* @param encoding - the encoding to use when writing log records.
|
* @param autoFlush - indicates whether the file should be flushed
|
* after every record written.
|
* @param append - indicates whether to append to the existing file or to
|
* overwrite it.
|
* @param bufferSize - the buffer size to use for the writer.
|
* @return a PrintWriter for the initial log file
|
* @throws IOException if the initial log file could not be opened
|
*/
|
private static PrintWriter getInitialWriter(FileNamingPolicy naming,
|
String encoding,
|
boolean autoFlush,
|
boolean append,
|
int bufferSize)
|
throws IOException
|
{
|
File file = naming.getInitialName();
|
return constructWriter(file, encoding, autoFlush, append, bufferSize);
|
}
|
|
/**
|
* Construct a PrintWriter for a file.
|
* @param file - the file to open for writing
|
* @param encoding - the encoding to use when writing log records.
|
* @param autoFlush - indicates whether the file should be flushed
|
* after every record written.
|
* @param append - indicates whether the file should be appended to or
|
* truncated.
|
* @param bufferSize - the buffer size to use for the writer.
|
* @return a PrintWriter for the specified file.
|
* @throws IOException if the PrintWriter could not be constructed
|
* or if the file already exists and it was indicated this should be
|
* an error.
|
*/
|
private static PrintWriter constructWriter(File file, String encoding,
|
boolean autoFlush, boolean append,
|
int bufferSize)
|
throws IOException
|
{
|
FileOutputStream fos= new FileOutputStream(file, append);
|
OutputStreamWriter osw= new OutputStreamWriter(fos, encoding);
|
BufferedWriter bw = null;
|
if(bufferSize <= 0)
|
{
|
bw= new BufferedWriter(osw);
|
}
|
else
|
{
|
bw= new BufferedWriter(osw, bufferSize);
|
}
|
return new PrintWriter(bw, autoFlush);
|
}
|
|
/**
|
* Creates a new instance of MultiFileTextWriter with the supplied policies.
|
*
|
* @param name the name of the log rotation thread.
|
* @param namingPolicy the file naming policy to use to name rotated log
|
* files.
|
* @throws IOException if an error occurs while creating the log file.
|
*/
|
public MultifileTextWriter(String name, FileNamingPolicy namingPolicy)
|
throws IOException
|
{
|
this(name, 5000, namingPolicy, UTF8_ENCODING,
|
true, true, BUFFER_SIZE, null, null);
|
}
|
|
/**
|
* Creates a new instance of MultiFileTextWriter with the supplied policies.
|
*
|
* @param name the name of the log rotation thread.
|
* @param interval the interval to check whether the logs need to be rotated.
|
* @param namingPolicy the file naming policy to use to name rotated log.
|
* files.
|
* @param encoding the encoding to use to write the log files.
|
* @param autoFlush whether to flush the writer on every println.
|
* @param append whether to append to an existing log file.
|
* @param bufferSize the bufferSize to use for the writer.
|
* @param rotationPolicies the rotation policy to use for log rotation.
|
* @param retentionPolicies the retention policy to use for log rotation.
|
* @throws IOException if an error occurs while creating the log file.
|
*/
|
public MultifileTextWriter(String name, int interval,
|
FileNamingPolicy namingPolicy, String encoding,
|
boolean autoFlush, boolean append, int bufferSize,
|
CopyOnWriteArrayList<RotationPolicy> rotationPolicies,
|
CopyOnWriteArrayList<RetentionPolicy> retentionPolicies)
|
throws IOException
|
{
|
super(getInitialWriter(namingPolicy, encoding,
|
autoFlush, append, bufferSize), true);
|
this.name = name;
|
this.interval = interval;
|
this.namingPolicy = namingPolicy;
|
this.rotationPolicies = rotationPolicies;
|
this.retentionPolicies = retentionPolicies;
|
|
this.encoding = encoding;
|
this.autoFlush = autoFlush;
|
this.append = append;
|
this.bufferSize = bufferSize;
|
|
this.stopRequested = false;
|
|
// We will lazily launch the rotaterThread
|
// to ensure initialization safety.
|
|
DirectoryServer.registerShutdownListener(this);
|
}
|
|
/**
|
* A rotater thread is responsible for checking if the log files need to be
|
* rotated based on the policies. It will do so if necessary.
|
*/
|
private class RotaterThread extends DirectoryThread
|
{
|
/**
|
* Create a new rotater thread.
|
*/
|
public RotaterThread()
|
{
|
super(name);
|
}
|
|
/**
|
* the run method of the rotaterThread. It wakes up periodically and checks
|
* whether the file needs to be rotated based on the rotation policy.
|
*/
|
public void run()
|
{
|
while(!isShuttingDown())
|
{
|
try
|
{
|
sleep(interval);
|
}
|
catch(InterruptedException e)
|
{
|
// We expect this to happen.
|
}
|
catch(Exception e)
|
{
|
if (debugEnabled())
|
{
|
debugCaught(DebugLogLevel.ERROR, e);
|
}
|
}
|
|
if(rotationPolicies != null)
|
{
|
for(RotationPolicy rotationPolicy : rotationPolicies)
|
{
|
if(rotationPolicy.rotateFile())
|
{
|
try
|
{
|
rotate();
|
}
|
catch (IOException ioe)
|
{
|
//TODO: Comment this after AOP logging is complete.
|
//int msgID = MSGID_CONFIG_LOGGER_ROTATE_FAILED;
|
//Error.logError(ErrorLogCategory.CORE_SERVER,
|
// ErrorLogSeverity.SEVERE_ERROR, msgID, ioe);
|
}
|
}
|
}
|
}
|
|
if(retentionPolicies != null)
|
{
|
for(RetentionPolicy retentionPolicy : retentionPolicies)
|
{
|
int numFilesDeleted = retentionPolicy.deleteFiles();
|
if (debugEnabled())
|
{
|
debugVerbose("%d files deleted by rentention policy",
|
numFilesDeleted);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* Retrieves the human-readable name for this shutdown listener.
|
*
|
* @return The human-readable name for this shutdown listener.
|
*/
|
public String getShutdownListenerName()
|
{
|
return "MultifileTextWriter Thread " + name;
|
}
|
|
/**
|
* Indicates that the Directory Server has received a request to stop running
|
* and that this shutdown listener should take any action necessary to prepare
|
* for it.
|
*
|
* @param reason The human-readable reason for the shutdown.
|
*/
|
public void processServerShutdown(String reason)
|
{
|
startShutDown();
|
|
// Wait for rotater to terminate
|
while (rotaterThread != null && rotaterThread.isAlive()) {
|
try {
|
rotaterThread.join();
|
}
|
catch (InterruptedException ex) {
|
// Ignore; we gotta wait..
|
}
|
}
|
|
writer.flush();
|
writer.close();
|
writer = null;
|
}
|
|
/**
|
* Queries whether the publisher is in shutdown mode.
|
*
|
* @return if the publish is in shutdown mode.
|
*/
|
private synchronized boolean isShuttingDown()
|
{
|
return stopRequested;
|
}
|
|
/**
|
* Tell the writer to start shutting down.
|
*/
|
private synchronized void startShutDown()
|
{
|
stopRequested = true;
|
}
|
|
/**
|
* Shutdown the text writer.
|
*/
|
public void shutdown()
|
{
|
processServerShutdown(null);
|
|
DirectoryServer.deregisterShutdownListener(this);
|
}
|
|
|
/**
|
* Write a log record string to the file.
|
*
|
* @param record the log record to write.
|
*/
|
public synchronized void writeRecord(String record)
|
{
|
// Launch writer rotaterThread if not running
|
if (rotaterThread == null) {
|
rotaterThread = new RotaterThread();
|
rotaterThread.start();
|
}
|
|
writer.println(record);
|
}
|
|
/**
|
* Tries to rotate the log files. If the new log file alreadly exists, it
|
* tries to rename the file. On failure, all subsequent log write requests
|
* will throw exceptions.
|
*
|
* @throws IOException if an error occurs while rotation the log files.
|
*/
|
public void rotate() throws IOException
|
{
|
writer.flush();
|
writer.close();
|
writer = null;
|
|
File currentFile = namingPolicy.getInitialName();
|
File newFile = namingPolicy.getNextName();
|
currentFile.renameTo(newFile);
|
|
writer = constructWriter(currentFile, encoding,
|
autoFlush, append, bufferSize);
|
|
//RotationActionThread rotThread =
|
// new RotationActionThread(newFile, actions, configEntry);
|
//rotThread.start();
|
}
|
|
/**
|
* Invokes the specified method with the provided arguments.
|
*
|
* @param methodName The name of the method to invoke.
|
* @param arguments The set of configuration attributes holding the
|
* arguments to use for the method.
|
*
|
* @return The return value for the method, or <CODE>null</CODE> if it did
|
* not return a value.
|
*
|
* @throws org.opends.server.types.DirectoryException
|
* If there was no such method, or if an error occurred while attempting
|
* to invoke it.
|
*/
|
public Object invokeMethod(String methodName, ConfigAttribute[] arguments)
|
throws DirectoryException
|
{
|
if(!methodName.equals("rotateNow"))
|
{
|
int msgID = MSGID_CONFIG_JMX_NO_METHOD;
|
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM,
|
getMessage(msgID), msgID);
|
}
|
|
try
|
{
|
rotate();
|
}
|
catch(Exception e)
|
{
|
//TODO: Comment when AOP logging framework is complete.
|
//int msgID = MSGID_CONFIG_LOGGER_ROTATE_FAILED;
|
//throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM,
|
// getMessage(msgID, e), msgID);
|
}
|
|
return null;
|
}
|
|
/**
|
* Retrieves a list of the methods that may be invoked for this component.
|
*
|
* @return A list of the methods that may be invoked for this component.
|
*/
|
public InvokableMethod[] getOperationSignatures()
|
{
|
InvokableMethod[] methods = new InvokableMethod[1];
|
methods[0] = new InvokableMethod("rotateNow",
|
"Rotate the log file immediately",
|
null, "void", true, true);
|
return methods;
|
}
|
|
/**
|
* This method sets the actions that need to be executed after rotation.
|
*
|
* @param actions An array of actions that need to be executed on rotation.
|
*/
|
public void setPostRotationActions(ArrayList<ActionType> actions)
|
{
|
this.actions = actions;
|
}
|
}
|
