/*
* 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.rolling;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.pattern.PatternConverter;
import org.apache.log4j.rolling.helper.Action;
import org.apache.log4j.rolling.helper.FileRenameAction;
import org.apache.log4j.rolling.helper.GZCompressAction;
import org.apache.log4j.rolling.helper.ZipCompressAction;
import org.apache.log4j.helpers.LogLog;
/**
* When rolling over, <code>FixedWindowRollingPolicy</code> renames files
* according to a fixed window algorithm as described below.
*
* <p>The <b>ActiveFileName</b> property, which is required, represents the name
* of the file where current logging output will be written.
* The <b>FileNamePattern</b> option represents the file name pattern for the
* archived (rolled over) log files. If present, the <b>FileNamePattern</b>
* option must include an integer token, that is the string "%i" somewhere
* within the pattern.
*
* <p>Let <em>max</em> and <em>min</em> represent the values of respectively
* the <b>MaxIndex</b> and <b>MinIndex</b> options. Let "foo.log" be the value
* of the <b>ActiveFile</b> option and "foo.%i.log" the value of
* <b>FileNamePattern</b>. Then, when rolling over, the file
* <code>foo.<em>max</em>.log</code> will be deleted, the file
* <code>foo.<em>max-1</em>.log</code> will be renamed as
* <code>foo.<em>max</em>.log</code>, the file <code>foo.<em>max-2</em>.log</code>
* renamed as <code>foo.<em>max-1</em>.log</code>, and so on,
* the file <code>foo.<em>min+1</em>.log</code> renamed as
* <code>foo.<em>min+2</em>.log</code>. Lastly, the active file <code>foo.log</code>
* will be renamed as <code>foo.<em>min</em>.log</code> and a new active file name
* <code>foo.log</code> will be created.
*
* <p>Given that this rollover algorithm requires as many file renaming
* operations as the window size, large window sizes are discouraged. The
* current implementation will automatically reduce the window size to 12 when
* larger values are specified by the user.
*
*
* @author Ceki Gülcü
* */
public final class FixedWindowRollingPolicy extends RollingPolicyBase {
/**
* It's almost always a bad idea to have a large window size, say over 12.
*/
private static final int MAX_WINDOW_SIZE = 12;
/**
* Index for oldest retained log file.
*/
private int maxIndex;
/**
* Index for most recent log file.
*/
private int minIndex;
/**
* if true, then an explicit name for the active file was
* specified using RollingFileAppender.file or the
* redundent RollingPolicyBase.setActiveFile
*/
private boolean explicitActiveFile;
/**
* Constructs a new instance.
*/
public FixedWindowRollingPolicy() {
minIndex = 1;
maxIndex = 7;
}
/**
* {@inheritDoc}
*/
public void activateOptions() {
super.activateOptions();
if (maxIndex < minIndex) {
LogLog.warn(
"MaxIndex (" + maxIndex + ") cannot be smaller than MinIndex ("
+ minIndex + ").");
LogLog.warn("Setting maxIndex to equal minIndex.");
maxIndex = minIndex;
}
if ((maxIndex - minIndex) > MAX_WINDOW_SIZE) {
LogLog.warn("Large window sizes are not allowed.");
maxIndex = minIndex + MAX_WINDOW_SIZE;
LogLog.warn("MaxIndex reduced to " + String.valueOf(maxIndex) + ".");
}
PatternConverter itc = getIntegerPatternConverter();
if (itc == null) {
throw new IllegalStateException(
"FileNamePattern [" + getFileNamePattern()
+ "] does not contain a valid integer format specifier");
}
}
/**
* {@inheritDoc}
*/
public RolloverDescription initialize(
final String file, final boolean append) {
String newActiveFile = file;
explicitActiveFile = false;
if (activeFileName != null) {
explicitActiveFile = true;
newActiveFile = activeFileName;
}
if (file != null) {
explicitActiveFile = true;
newActiveFile = file;
}
if (!explicitActiveFile) {
StringBuffer buf = new StringBuffer();
formatFileName(new Integer(minIndex), buf);
newActiveFile = buf.toString();
}
return new RolloverDescriptionImpl(newActiveFile, append, null, null);
}
/**
* {@inheritDoc}
*/
public RolloverDescription rollover(final String currentFileName) {
if (maxIndex >= 0) {
int purgeStart = minIndex;
if (!explicitActiveFile) {
purgeStart++;
}
if (!purge(purgeStart, maxIndex)) {
return null;
}
StringBuffer buf = new StringBuffer();
formatFileName(new Integer(purgeStart), buf);
String renameTo = buf.toString();
String compressedName = renameTo;
Action compressAction = null;
if (renameTo.endsWith(".gz")) {
renameTo = renameTo.substring(0, renameTo.length() - 3);
compressAction =
new GZCompressAction(
new File(renameTo), new File(compressedName), true);
} else if (renameTo.endsWith(".zip")) {
renameTo = renameTo.substring(0, renameTo.length() - 4);
compressAction =
new ZipCompressAction(
new File(renameTo), new File(compressedName), true);
}
FileRenameAction renameAction =
new FileRenameAction(
new File(currentFileName), new File(renameTo), false);
return new RolloverDescriptionImpl(
currentFileName, false, renameAction, compressAction);
}
return null;
}
/**
* Get index of oldest log file to be retained.
* @return index of oldest log file.
*/
public int getMaxIndex() {
return maxIndex;
}
/**
* Get index of most recent log file.
* @return index of oldest log file.
*/
public int getMinIndex() {
return minIndex;
}
/**
* Set index of oldest log file to be retained.
* @param maxIndex index of oldest log file to be retained.
*/
public void setMaxIndex(int maxIndex) {
this.maxIndex = maxIndex;
}
/**
* Set index of most recent log file.
* @param minIndex Index of most recent log file.
*/
public void setMinIndex(int minIndex) {
this.minIndex = minIndex;
}
/**
* Purge and rename old log files in preparation for rollover
* @param lowIndex low index
* @param highIndex high index. Log file associated with high
* index will be deleted if needed.
* @return true if purge was successful and rollover should be attempted.
*/
private boolean purge(final int lowIndex, final int highIndex) {
int suffixLength = 0;
List renames = new ArrayList();
StringBuffer buf = new StringBuffer();
formatFileName(new Integer(lowIndex), buf);
String lowFilename = buf.toString();
if (lowFilename.endsWith(".gz")) {
suffixLength = 3;
} else if (lowFilename.endsWith(".zip")) {
suffixLength = 4;
}
for (int i = lowIndex; i <= highIndex; i++) {
File toRename = new File(lowFilename);
boolean isBase = false;
if (suffixLength > 0) {
File toRenameBase =
new File(
lowFilename.substring(0, lowFilename.length() - suffixLength));
if (toRename.exists()) {
if (toRenameBase.exists()) {
toRenameBase.delete();
}
} else {
toRename = toRenameBase;
isBase = true;
}
}
if (toRename.exists()) {
//
// if at upper index then
// attempt to delete last file
// if that fails then abandon purge
if (i == highIndex) {
if (!toRename.delete()) {
return false;
}
break;
}
//
// if intermediate index
// add a rename action to the list
buf.setLength(0);
formatFileName(new Integer(i + 1), buf);
String highFilename = buf.toString();
String renameTo = highFilename;
if (isBase) {
renameTo =
highFilename.substring(0, highFilename.length() - suffixLength);
}
renames.add(new FileRenameAction(toRename, new File(renameTo), true));
lowFilename = highFilename;
} else {
break;
}
}
//
// work renames backwards
//
for (int i = renames.size() - 1; i >= 0; i--) {
Action action = (Action) renames.get(i);
try {
if (!action.execute()) {
return false;
}
} catch (Exception ex) {
LogLog.warn("Exception during purge in RollingFileAppender", ex);
return false;
}
}
return true;
}
}