/*
|
* 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 Sun Microsystems, Inc.
|
*/
|
package org.opends.server.loggers;
|
|
import java.io.BufferedOutputStream;
|
import java.io.BufferedWriter;
|
import java.io.File;
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.io.OutputStreamWriter;
|
import java.io.Writer;
|
import java.util.ArrayList;
|
import java.util.logging.ErrorManager;
|
import java.util.logging.Handler;
|
import java.util.logging.Level;
|
import java.util.logging.LogRecord;
|
|
import org.opends.server.api.InvokableComponent;
|
import org.opends.server.core.DirectoryException;
|
import org.opends.server.config.ConfigAttribute;
|
import org.opends.server.config.ConfigEntry;
|
import org.opends.server.types.DN;
|
import org.opends.server.types.InvokableMethod;
|
import org.opends.server.types.ResultCode;
|
import org.opends.server.util.TimeThread;
|
|
import static org.opends.server.config.ConfigConstants.*;
|
import static org.opends.server.messages.ConfigMessages.*;
|
import static org.opends.server.messages.MessageHandler.*;
|
|
/**
|
* Simple file logging <tt>Handler</tt>.
|
* The <tt>DirectoryFileHandler</tt> can write to a specified file,
|
* and can handle rotating the file based on predefined policies.
|
*/
|
public class DirectoryFileHandler extends Handler
|
implements LoggerAlarmHandler, InvokableComponent
|
{
|
private Writer writer;
|
private MeteredStream meter;
|
private boolean append;
|
private String filename;
|
private int bufferSize = 65536;
|
private long limit = 0;
|
private File file;
|
private ArrayList<ActionType> actions;
|
private ConfigEntry configEntry;
|
|
|
/**
|
* Initialize a DirectoryFileHandler to write to the given filename.
|
*
|
* @param configEntry The configuration entry for the associated logger.
|
* @param filename the name of the output file.
|
* @param bufferSize the buffer size before flushing data to the file.
|
* @exception IOException if there are IO problems opening the files.
|
* @exception SecurityException if a security manager exists and if
|
* the caller does not have <tt>LoggingPermission("control")</tt>.
|
*/
|
public DirectoryFileHandler(ConfigEntry configEntry,
|
String filename, int bufferSize)
|
throws IOException, SecurityException
|
{
|
this.configEntry = configEntry;
|
this.bufferSize = bufferSize;
|
configure();
|
this.filename = filename;
|
openFile();
|
}
|
|
/**
|
* Initialize a DirectoryFileHandler to write to the given filename,
|
* with optional append.
|
*
|
* @param configEntry The configuration entry for the associated logger.
|
* @param filename the name of the output file
|
* @param append specifies append mode
|
* @param bufferSize the buffer size before flushing data to the file.
|
* @exception IOException if there are IO problems opening the files.
|
* @exception SecurityException if a security manager exists and if
|
* the caller does not have <tt>LoggingPermission("control")</tt>.
|
*/
|
public DirectoryFileHandler(ConfigEntry configEntry,
|
String filename, boolean append, int bufferSize)
|
throws IOException, SecurityException
|
{
|
this.configEntry = configEntry;
|
this.bufferSize = bufferSize;
|
configure();
|
this.filename = filename;
|
this.append = append;
|
openFile();
|
}
|
|
|
/**
|
* Set the maximum file size limit.
|
*
|
* @param limit The maximum file size.
|
*/
|
public void setFileSize(long limit)
|
{
|
this.limit = limit;
|
}
|
|
|
/**
|
* Private method to open the set of output files, based on the
|
* configured instance variables.
|
*
|
* @exception IOException If there was an error while opening the file.
|
* @exception SecurityException If a security manager exists and if
|
* the caller does not have LoggingPermission.
|
*/
|
private void openFile() throws IOException, SecurityException
|
{
|
// We register our own ErrorManager during initialization
|
// so we can record exceptions.
|
InitializationErrorManager em = new InitializationErrorManager();
|
setErrorManager(em);
|
|
file = new File(filename);
|
|
// Create the initial log file.
|
if (append)
|
{
|
open(file, true);
|
} else
|
{
|
// FIXME - Should we rotate?
|
open(file, false);
|
}
|
|
// Did we detect any exceptions during initialization?
|
Exception ex = em.lastException;
|
if (ex != null)
|
{
|
if (ex instanceof IOException)
|
{
|
throw (IOException) ex;
|
} else if (ex instanceof SecurityException)
|
{
|
throw (SecurityException) ex;
|
} else
|
{
|
throw new IOException("Exception: " + ex);
|
}
|
}
|
|
// Install the normal default ErrorManager.
|
setErrorManager(new ErrorManager());
|
}
|
|
|
/**
|
* Rotate the current file to the specified new file name.
|
* @param newFile The name of the new file to rotate to.
|
*/
|
public void rotate(String newFile)
|
{
|
close();
|
File f1 = file;
|
File f2 = new File(newFile);
|
if (f1.exists())
|
{
|
if (f2.exists())
|
{
|
System.err.println("File:" + f2 + " already exists. Renaming...");
|
File f3 = new File(newFile + ".sav");
|
f2.renameTo(f3);
|
}
|
f1.renameTo(f2);
|
}
|
try
|
{
|
open(file, false);
|
} catch (IOException ix)
|
{
|
// We don't want to throw an exception here, but we
|
// report the exception to any registered ErrorManager.
|
reportError(null, ix, ErrorManager.OPEN_FAILURE);
|
}
|
}
|
|
/**
|
* Format and publish a <tt>LogRecord</tt>.
|
*
|
* @param record Description of the log event. A null record is
|
* silently ignored and is not published.
|
*
|
*/
|
public void publish(LogRecord record)
|
{
|
String msg;
|
try
|
{
|
msg = getFormatter().format(record);
|
} catch (Exception ex)
|
{
|
reportError(null, ex, ErrorManager.WRITE_FAILURE);
|
return;
|
}
|
|
synchronized(this)
|
{
|
try
|
{
|
writer.write(msg);
|
} catch (Exception ex)
|
{
|
reportError(null, ex, ErrorManager.WRITE_FAILURE);
|
return;
|
}
|
|
if(limit > 0 && meter.written >= limit)
|
{
|
rollover();
|
}
|
}
|
}
|
|
|
/**
|
* Return the number of bytes written to the current file.
|
*
|
* @return The number of bytes written to the current file.
|
*/
|
public long getFileSize()
|
{
|
return meter.written;
|
}
|
|
/**
|
* This method is called from by the logger thread when a
|
* file rotation needs to happen.
|
*/
|
public void rollover()
|
{
|
String newfilename = filename + "." + getFileExtension();
|
rotate(newfilename);
|
|
RotationActionThread rotThread =
|
new RotationActionThread(newfilename, actions, configEntry);
|
rotThread.start();
|
|
}
|
|
/**
|
* 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;
|
}
|
|
|
/**
|
* Retrieves the DN of the configuration entry with which this component is
|
* associated.
|
*
|
* @return The DN of the configuration entry with which this component is
|
* associated.
|
*/
|
public DN getInvokableComponentEntryDN()
|
{
|
return configEntry.getDN();
|
}
|
|
|
|
/**
|
* 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;
|
}
|
|
|
|
/**
|
* 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 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);
|
}
|
|
rollover();
|
|
return null;
|
}
|
|
|
/**
|
* Close the current output stream.
|
*
|
*/
|
public void close()
|
{
|
flushAndClose();
|
}
|
|
|
/**
|
* Return the extension for the target filename for the rotated file.
|
*
|
* @return The extension for the target filename for the rotated file.
|
*/
|
private String getFileExtension()
|
{
|
return TimeThread.getUTCTime();
|
}
|
|
|
/**
|
* Open the file and set the appropriate output stream.
|
*
|
* @param fname The path and name of the file to be written.
|
* @param append Indicates whether to append to the existing file or to
|
* overwrite it.
|
*
|
* @throws IOException If a problem occurs while opening the file.
|
*/
|
private void open(File fname, boolean append) throws IOException
|
{
|
long len = 0;
|
if (append)
|
{
|
len = fname.length();
|
}
|
FileOutputStream fout = new FileOutputStream(fname, append);
|
BufferedOutputStream bout = null;
|
if(bufferSize <= 0)
|
{
|
bout = new BufferedOutputStream(fout);
|
} else
|
{
|
bout = new BufferedOutputStream(fout, bufferSize);
|
}
|
meter = new MeteredStream(bout, len);
|
// flushAndClose();
|
writer = new BufferedWriter(new OutputStreamWriter(meter));
|
}
|
|
|
/**
|
* Private method to configure a DirectoryFileHandler
|
* with default values.
|
*/
|
private void configure()
|
{
|
setLevel(Level.ALL);
|
this.append = true;
|
}
|
|
|
/**
|
* Flush any buffered messages and close the output stream.
|
*/
|
private void flushAndClose()
|
{
|
if (writer != null)
|
{
|
try
|
{
|
writer.flush();
|
writer.close();
|
} catch (Exception ex) {
|
// We don't want to throw an exception here, but we
|
// report the exception to any registered ErrorManager.
|
reportError(null, ex, ErrorManager.CLOSE_FAILURE);
|
}
|
writer = null;
|
}
|
|
}
|
|
/**
|
* Flush any buffered messages.
|
*/
|
public void flush()
|
{
|
if (writer != null)
|
{
|
try
|
{
|
writer.flush();
|
} catch (Exception ex) {
|
// We don't want to throw an exception here, but we
|
// report the exception to any registered ErrorManager.
|
reportError(null, ex, ErrorManager.FLUSH_FAILURE);
|
}
|
}
|
}
|
|
|
}
|
