You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by ri...@apache.org on 2007/03/21 17:26:09 UTC
svn commit: r520938 - in /incubator/qpid/branches/M2/java/broker:
etc/log4j.xml src/main/java/org/apache/log4j/
src/main/java/org/apache/log4j/QpidCompositeRollingAppender.java
Author: ritchiem
Date: Wed Mar 21 09:26:03 2007
New Revision: 520938
URL: http://svn.apache.org/viewvc?view=rev&rev=520938
Log:
Added a new Appender from the Log4j contrib code base as QpidCompositeRollingAppender. This will allow us to roll the broker log files on a set time frame AND to a maximum file size. The CompositeRollingAppender was contributed by Kevin Steppe to the log4j project but as it is not part of the log4j.jar we must include it in our own code base until log4j provide a core implementation.
Added:
incubator/qpid/branches/M2/java/broker/src/main/java/org/apache/log4j/
incubator/qpid/branches/M2/java/broker/src/main/java/org/apache/log4j/QpidCompositeRollingAppender.java (with props)
Modified:
incubator/qpid/branches/M2/java/broker/etc/log4j.xml
Modified: incubator/qpid/branches/M2/java/broker/etc/log4j.xml
URL: http://svn.apache.org/viewvc/incubator/qpid/branches/M2/java/broker/etc/log4j.xml?view=diff&rev=520938&r1=520937&r2=520938
==============================================================================
--- incubator/qpid/branches/M2/java/broker/etc/log4j.xml (original)
+++ incubator/qpid/branches/M2/java/broker/etc/log4j.xml Wed Mar 21 09:26:03 2007
@@ -21,9 +21,17 @@
-->
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
- <appender name="FileAppender" class="org.apache.log4j.FileAppender">
+ <appender name="FileAppender" class="org.apache.log4j.QpidCompositeRollingAppender">
+ <param name="staticLogFileName" value="false"/>
<param name="File" value="${QPID_WORK}/log/${logprefix}qpid${logsuffix}.log"/>
<param name="Append" value="false"/>
+ <!-- Change the direction so newer files have bigger numbers -->
+ <!-- So log.1 is written then log.2 etc This prevents a lot of file renames at log rollover -->
+ <param name="CountDirection" value="1"/>
+ <!--param name="MaxFileSize" value="1000"/ Use default 10MB -->
+ <param name="DatePattern" value="'.'yyyy-MM-dd-HH-mm"/>
+ <!-- Unlimited number of backups -->
+ <param name="MaxSizeRollBackups" value="-1"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%t %-5p %c{2} - %m%n"/>
Added: incubator/qpid/branches/M2/java/broker/src/main/java/org/apache/log4j/QpidCompositeRollingAppender.java
URL: http://svn.apache.org/viewvc/incubator/qpid/branches/M2/java/broker/src/main/java/org/apache/log4j/QpidCompositeRollingAppender.java?view=auto&rev=520938
==============================================================================
--- incubator/qpid/branches/M2/java/broker/src/main/java/org/apache/log4j/QpidCompositeRollingAppender.java (added)
+++ incubator/qpid/branches/M2/java/broker/src/main/java/org/apache/log4j/QpidCompositeRollingAppender.java Wed Mar 21 09:26:03 2007
@@ -0,0 +1,710 @@
+/*
+ * 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;
+
+import org.apache.log4j.helpers.OptionConverter;
+import org.apache.log4j.helpers.CountingQuietWriter;
+import org.apache.log4j.helpers.LogLog;
+import org.apache.log4j.spi.LoggingEvent;
+
+import java.util.Date;
+import java.text.SimpleDateFormat;
+import java.io.IOException;
+import java.io.Writer;
+import java.io.File;
+
+/**
+ * <p>CompositeRollingAppender combines RollingFileAppender and DailyRollingFileAppender<br>
+ * It can function as either or do both at the same time (making size
+ * based rolling files like RollingFileAppender until a data/time boundary
+ * is crossed at which time it rolls all of those files as per the DailyRollingFileAppender)
+ * based on the setting for <code>rollingStyle</code>.<br>
+ * <br>
+ * To use CompositeRollingAppender to roll log files as they reach a certain
+ * size (like RollingFileAppender), set rollingStyle=1 (@see config.size)<br>
+ * To use CompositeRollingAppender to roll log files at certain time intervals
+ * (daily for example), set rollingStyle=2 and a datePattern (@see config.time)<br>
+ * To have CompositeRollingAppender roll log files at a certain size AND rename those
+ * according to time intervals, set rollingStyle=3 (@see config.composite)<br>
+ *
+ * <p>A of few additional optional features have been added:<br>
+ * -- Attach date pattern for current log file (@see staticLogFileName)<br>
+ * -- Backup number increments for newer files (@see countDirection)<br>
+ * -- Infinite number of backups by file size (@see maxSizeRollBackups)<br>
+ * <br>
+ * <p>A few notes and warnings: For large or infinite number of backups
+ * countDirection > 0 is highly recommended, with staticLogFileName = false if
+ * time based rolling is also used -- this will reduce the number of file renamings
+ * to few or none. Changing staticLogFileName or countDirection without clearing
+ * the directory could have nasty side effects. If Date/Time based rolling
+ * is enabled, CompositeRollingAppender will attempt to roll existing files
+ * in the directory without a date/time tag based on the last modified date
+ * of the base log files last modification.<br>
+ * <br>
+ * <p>A maximum number of backups based on date/time boundries would be nice
+ * but is not yet implemented.<br>
+ *
+ * @author Kevin Steppe
+ * @author Heinz Richter
+ * @author Eirik Lygre
+ * @author Ceki Gülcü
+ * @author Martin Ritchie
+ */
+public class QpidCompositeRollingAppender extends FileAppender
+{
+ // The code assumes that the following 'time' constants are in a increasing
+ // sequence.
+ static final int TOP_OF_TROUBLE=-1;
+ static final int TOP_OF_MINUTE = 0;
+ static final int TOP_OF_HOUR = 1;
+ static final int HALF_DAY = 2;
+ static final int TOP_OF_DAY = 3;
+ static final int TOP_OF_WEEK = 4;
+ static final int TOP_OF_MONTH = 5;
+
+ /** Style of rolling to use */
+ static final int BY_SIZE = 1;
+ static final int BY_DATE = 2;
+ static final int BY_COMPOSITE = 3;
+
+ //Not currently used
+ static final String S_BY_SIZE = "Size";
+ static final String S_BY_DATE = "Date";
+ static final String S_BY_COMPOSITE = "Composite";
+
+ /**
+ The date pattern. By default, the pattern is set to
+ "'.'yyyy-MM-dd" meaning daily rollover.
+ */
+ private String datePattern = "'.'yyyy-MM-dd";
+
+ /** The actual formatted filename that is currently being written to
+ or will be the file transferred to on roll over
+ (based on staticLogFileName). */
+ private String scheduledFilename = null;
+
+ /** The timestamp when we shall next recompute the filename. */
+ private long nextCheck = System.currentTimeMillis () - 1;
+
+ /** Holds date of last roll over */
+ Date now = new Date();
+
+ SimpleDateFormat sdf;
+
+ /** Helper class to determine next rollover time */
+ RollingCalendar rc = new RollingCalendar();
+
+ /** Current period for roll overs */
+ int checkPeriod = TOP_OF_TROUBLE;
+
+ /** The default maximum file size is 10MB. */
+ protected long maxFileSize = 10*1024*1024;
+
+ /** There is zero backup files by default. */
+ protected int maxSizeRollBackups = 0;
+ /** How many sized based backups have been made so far */
+ protected int curSizeRollBackups = 0;
+
+ /** not yet implemented */
+ protected int maxTimeRollBackups = -1;
+ protected int curTimeRollBackups = 0;
+
+ /** By default newer files have lower numbers. (countDirection < 0)
+ * ie. log.1 is most recent, log.5 is the 5th backup, etc...
+ * countDirection > 0 does the opposite ie.
+ * log.1 is the first backup made, log.5 is the 5th backup made, etc.
+ * For infinite backups use countDirection > 0 to reduce rollOver costs.
+ */
+ protected int countDirection = -1;
+
+ /** Style of rolling to Use. BY_SIZE (1), BY_DATE(2), BY COMPOSITE(3) */
+ protected int rollingStyle = BY_COMPOSITE;
+ protected boolean rollDate = true;
+ protected boolean rollSize = true;
+
+ /** By default file.log is always the current file. Optionally
+ * file.log.yyyy-mm-dd for current formated datePattern can by the currently
+ * logging file (or file.log.curSizeRollBackup or even
+ * file.log.yyyy-mm-dd.curSizeRollBackup) This will make time based roll
+ * overs with a large number of backups much faster -- it won't have to
+ * rename all the backups!
+ */
+ protected boolean staticLogFileName = true;
+
+ /** FileName provided in configuration. Used for rolling properly */
+ protected String baseFileName;
+
+ /** The default constructor does nothing. */
+ public QpidCompositeRollingAppender() {
+ }
+
+ /**
+ Instantiate a <code>CompositeRollingAppender</code> and open the
+ file designated by <code>filename</code>. The opened filename will
+ become the ouput destination for this appender.
+ */
+ public QpidCompositeRollingAppender(Layout layout, String filename,
+ String datePattern) throws IOException
+ {
+ this(layout, filename, datePattern, true);
+ }
+
+ /**
+ Instantiate a CompositeRollingAppender and open the file designated by
+ <code>filename</code>. The opened filename will become the ouput
+ destination for this appender.
+
+ <p>If the <code>append</code> parameter is true, the file will be
+ appended to. Otherwise, the file desginated by
+ <code>filename</code> will be truncated before being opened.
+ */
+ public QpidCompositeRollingAppender(Layout layout, String filename, boolean append)
+ throws IOException {
+ super(layout, filename, append);
+ }
+
+ /**
+ Instantiate a CompositeRollingAppender and open the file designated by
+ <code>filename</code>. The opened filename will become the ouput
+ destination for this appender.
+ */
+ public QpidCompositeRollingAppender(Layout layout, String filename,
+ String datePattern, boolean append) throws IOException {
+ super(layout, filename, append);
+ this.datePattern = datePattern;
+ activateOptions();
+ }
+ /**
+ Instantiate a CompositeRollingAppender and open the file designated by
+ <code>filename</code>. The opened filename will become the output
+ destination for this appender.
+
+ <p>The file will be appended to. DatePattern is default.
+ */
+ public QpidCompositeRollingAppender(Layout layout, String filename) throws IOException {
+ super(layout, filename);
+ }
+
+ /**
+ The <b>DatePattern</b> takes a string in the same format as
+ expected by {@link java.text.SimpleDateFormat}. This options determines the
+ rollover schedule.
+ */
+ public void setDatePattern(String pattern) {
+ datePattern = pattern;
+ }
+
+ /** Returns the value of the <b>DatePattern</b> option. */
+ public String getDatePattern() {
+ return datePattern;
+ }
+
+ /**
+ Returns the value of the <b>maxSizeRollBackups</b> option.
+ */
+ public int getMaxSizeRollBackups() {
+ return maxSizeRollBackups;
+ }
+
+ /**
+ Get the maximum size that the output file is allowed to reach
+ before being rolled over to backup files.
+
+ @since 1.1
+ */
+ public long getMaximumFileSize() {
+ return maxFileSize;
+ }
+
+ /**
+ <p>Set the maximum number of backup files to keep around based on file size.
+
+ <p>The <b>MaxSizeRollBackups</b> option determines how many backup
+ files are kept before the oldest is erased. This option takes
+ an integer value. If set to zero, then there will be no
+ backup files and the log file will be truncated when it reaches
+ <code>MaxFileSize</code>. If a negative number is supplied then
+ no deletions will be made. Note that this could result in
+ very slow performance as a large number of files are rolled over unless
+ {@link #setCountDirection} up is used.
+
+ <p>The maximum applys to -each- time based group of files and -not- the total.
+ Using a daily roll the maximum total files would be (#days run) * (maxSizeRollBackups)
+
+ */
+ public void setMaxSizeRollBackups(int maxBackups) {
+ maxSizeRollBackups = maxBackups;
+ }
+
+ /**
+ Set the maximum size that the output file is allowed to reach
+ before being rolled over to backup files.
+
+ <p>This method is equivalent to {@link #setMaxFileSize} except
+ that it is required for differentiating the setter taking a
+ <code>long</code> argument from the setter taking a
+ <code>String</code> argument by the JavaBeans {@link
+ java.beans.Introspector Introspector}.
+
+ @see #setMaxFileSize(String)
+ */
+ public void setMaxFileSize(long maxFileSize) {
+ this.maxFileSize = maxFileSize;
+ }
+
+ /**
+ Set the maximum size that the output file is allowed to reach
+ before being rolled over to backup files.
+
+ <p>This method is equivalent to {@link #setMaxFileSize} except
+ that it is required for differentiating the setter taking a
+ <code>long</code> argument from the setter taking a
+ <code>String</code> argument by the JavaBeans {@link
+ java.beans.Introspector Introspector}.
+
+ @see #setMaxFileSize(String)
+ */
+ public void setMaximumFileSize(long maxFileSize) {
+ this.maxFileSize = maxFileSize;
+ }
+
+ /**
+ Set the maximum size that the output file is allowed to reach
+ before being rolled over to backup files.
+
+ <p>In configuration files, the <b>MaxFileSize</b> option takes an
+ long integer in the range 0 - 2^63. You can specify the value
+ with the suffixes "KB", "MB" or "GB" so that the integer is
+ interpreted being expressed respectively in kilobytes, megabytes
+ or gigabytes. For example, the value "10KB" will be interpreted
+ as 10240.
+ */
+ public void setMaxFileSize(String value) {
+ maxFileSize = OptionConverter.toFileSize(value, maxFileSize + 1);
+ }
+
+ protected void setQWForFiles(Writer writer) {
+ qw = new CountingQuietWriter(writer, errorHandler);
+ }
+
+ //Taken verbatum from DailyRollingFileAppender
+ int computeCheckPeriod() {
+ RollingCalendar c = new RollingCalendar();
+ // set sate to 1970-01-01 00:00:00 GMT
+ Date epoch = new Date(0);
+ if(datePattern != null) {
+ for(int i = TOP_OF_MINUTE; i <= TOP_OF_MONTH; i++) {
+ String r0 = sdf.format(epoch);
+ c.setType(i);
+ Date next = new Date(c.getNextCheckMillis(epoch));
+ String r1 = sdf.format(next);
+ //LogLog.debug("Type = "+i+", r0 = "+r0+", r1 = "+r1);
+ if(r0 != null && r1 != null && !r0.equals(r1)) {
+ return i;
+ }
+ }
+ }
+ return TOP_OF_TROUBLE; // Deliberately head for trouble...
+ }
+
+ //Now for the new stuff
+ /**
+ * Handles append time behavior for CompositeRollingAppender. This checks
+ * if a roll over either by date (checked first) or time (checked second)
+ * is need and then appends to the file last.
+ */
+ protected void subAppend(LoggingEvent event) {
+
+ if (rollDate) {
+ long n = System.currentTimeMillis();
+ if (n >= nextCheck) {
+ now.setTime(n);
+ nextCheck = rc.getNextCheckMillis(now);
+
+ rollOverTime();
+ }
+ }
+
+ if (rollSize) {
+ if ((fileName != null) && ((CountingQuietWriter) qw).getCount() >= maxFileSize) {
+ rollOverSize();
+ }
+ }
+
+ super.subAppend(event);
+ }
+
+ public void setFile(String file)
+ {
+ baseFileName = file.trim();
+ fileName = file.trim();
+ }
+
+ /**
+ * Creates and opens the file for logging. If <code>staticLogFileName</code>
+ * is false then the fully qualified name is determined and used.
+ */
+ public synchronized void setFile(String fileName, boolean append) throws IOException {
+ if (!staticLogFileName) {
+ scheduledFilename = fileName = fileName.trim() + sdf.format(now);
+ if (countDirection > 0) {
+ scheduledFilename = fileName = fileName + '.' + (++curSizeRollBackups);
+ }
+ }
+
+ super.setFile(fileName, append, bufferedIO, bufferSize);
+
+ if(append) {
+ File f = new File(fileName);
+ ((CountingQuietWriter) qw).setCount(f.length());
+ }
+ }
+
+ public int getCountDirection() {
+ return countDirection;
+ }
+
+ public void setCountDirection(int direction) {
+ countDirection = direction;
+ }
+
+ public int getRollingStyle () {
+ return rollingStyle;
+ }
+
+ public void setRollingStyle(int style) {
+ rollingStyle = style;
+ switch (rollingStyle) {
+ case BY_SIZE:
+ rollDate = false;
+ rollSize = true;
+ break;
+ case BY_DATE:
+ rollDate = true;
+ rollSize = false;
+ break;
+ case BY_COMPOSITE:
+ rollDate = true;
+ rollSize = true;
+ break;
+ default:
+ errorHandler.error("Invalid rolling Style, use 1 (by size only), 2 (by date only) or 3 (both)");
+ }
+ }
+
+/*
+ public void setRollingStyle(String style) {
+ if (style == S_BY_SIZE) {
+ rollingStyle = BY_SIZE;
+ }
+ else if (style == S_BY_DATE) {
+ rollingStyle = BY_DATE;
+ }
+ else if (style == S_BY_COMPOSITE) {
+ rollingStyle = BY_COMPOSITE;
+ }
+ }
+*/
+ public boolean getStaticLogFileName() {
+ return staticLogFileName;
+ }
+
+ public void setStaticLogFileName(boolean s) {
+ staticLogFileName = s;
+ }
+
+ public void setStaticLogFileName(String value) {
+ setStaticLogFileName(OptionConverter.toBoolean(value, true));
+ }
+
+ /**
+ * Initializes based on exisiting conditions at time of <code>
+ * activateOptions</code>. The following is done:<br>
+ * <br>
+ * A) determine curSizeRollBackups<br>
+ * B) determine curTimeRollBackups (not implemented)<br>
+ * C) initiates a roll over if needed for crossing a date boundary since
+ * the last run.
+ */
+ protected void existingInit() {
+
+ curSizeRollBackups = 0;
+ curTimeRollBackups = 0;
+
+ //part A starts here
+ String filter;
+ if (staticLogFileName || !rollDate) {
+ filter = baseFileName + ".*";
+ }
+ else {
+ filter = scheduledFilename + ".*";
+ }
+
+ File f = new File(baseFileName);
+ f = f.getParentFile();
+ if (f == null)
+ f = new File(".");
+
+ LogLog.debug("Searching for existing files in: " + f);
+ String[] files = f.list();
+
+ if (files != null) {
+ for (int i = 0; i < files.length; i++) {
+ if (!files[i].startsWith(baseFileName))
+ continue;
+
+ int index = files[i].lastIndexOf(".");
+
+ if (staticLogFileName) {
+ int endLength = files[i].length() - index;
+ if (baseFileName.length() + endLength != files[i].length()) {
+ //file is probably scheduledFilename + .x so I don't care
+ continue;
+ }
+ }
+
+ try {
+ int backup = Integer.parseInt(files[i].substring(index + 1, files[i].length()));
+ LogLog.debug("From file: " + files[i] + " -> " + backup);
+ if (backup > curSizeRollBackups)
+ curSizeRollBackups = backup;
+ }
+ catch (Exception e) {
+ //this happens when file.log -> file.log.yyyy-mm-dd which is normal
+ //when staticLogFileName == false
+ LogLog.debug("Encountered a backup file not ending in .x " + files[i]);
+ }
+ }
+ }
+ LogLog.debug("curSizeRollBackups starts at: " + curSizeRollBackups);
+ //part A ends here
+
+ //part B not yet implemented
+
+ //part C
+ if (staticLogFileName && rollDate) {
+ File old = new File(baseFileName);
+ if (old.exists()) {
+ Date last = new Date(old.lastModified());
+ if (!(sdf.format(last).equals(sdf.format(now)))) {
+ scheduledFilename = baseFileName + sdf.format(last);
+ LogLog.debug("Initial roll over to: " + scheduledFilename);
+ rollOverTime();
+ }
+ }
+ }
+ LogLog.debug("curSizeRollBackups after rollOver at: " + curSizeRollBackups);
+ //part C ends here
+
+ }
+
+ /**
+ * Sets initial conditions including date/time roll over information, first check,
+ * scheduledFilename, and calls <code>existingInit</code> to initialize
+ * the current # of backups.
+ */
+ public void activateOptions() {
+
+ //REMOVE removed rollDate from boolean to enable Alex's change
+ if(datePattern != null) {
+ now.setTime(System.currentTimeMillis());
+ sdf = new SimpleDateFormat(datePattern);
+ int type = computeCheckPeriod();
+ //printPeriodicity(type);
+ rc.setType(type);
+ //next line added as this removes the name check in rollOver
+ nextCheck = rc.getNextCheckMillis(now);
+ } else {
+ if (rollDate)
+ LogLog.error("Either DatePattern or rollingStyle options are not set for ["+
+ name+"].");
+ }
+
+ existingInit();
+
+ super.activateOptions();
+
+ if (rollDate && fileName != null && scheduledFilename == null)
+ scheduledFilename = fileName + sdf.format(now);
+ }
+
+ /**
+ Rollover the file(s) to date/time tagged file(s).
+ Opens the new file (through setFile) and resets curSizeRollBackups.
+ */
+ protected void rollOverTime() {
+
+ curTimeRollBackups++;
+
+ //delete the old stuff here
+
+ if (staticLogFileName) {
+ /* Compute filename, but only if datePattern is specified */
+ if (datePattern == null) {
+ errorHandler.error("Missing DatePattern option in rollOver().");
+ return;
+ }
+
+ //is the new file name equivalent to the 'current' one
+ //something has gone wrong if we hit this -- we should only
+ //roll over if the new file will be different from the old
+ String dateFormat = sdf.format(now);
+ if (scheduledFilename.equals(fileName + dateFormat)) {
+ errorHandler.error("Compare " + scheduledFilename + " : " + fileName + dateFormat);
+ return;
+ }
+
+ // close current file, and rename it to datedFilename
+ this.closeFile();
+
+ //we may have to roll over a large number of backups here
+ String from, to;
+ for (int i = 1; i <= curSizeRollBackups; i++) {
+ from = fileName + '.' + i;
+ to = scheduledFilename + '.' + i;
+ rollFile(from, to);
+ }
+
+ rollFile(fileName, scheduledFilename);
+ }
+
+ try {
+ // This will also close the file. This is OK since multiple
+ // close operations are safe.
+ curSizeRollBackups = 0; //We're cleared out the old date and are ready for the new
+
+ //new scheduled name
+ scheduledFilename = fileName + sdf.format(now);
+ this.setFile(baseFileName, false);
+ }
+ catch(IOException e) {
+ errorHandler.error("setFile("+fileName+", false) call failed.");
+ }
+
+ }
+
+ /** Renames file <code>from</code> to file <code>to</code>. It
+ * also checks for existence of target file and deletes if it does.
+ */
+ protected static void rollFile(String from, String to) {
+ File target = new File(to);
+ if (target.exists()) {
+ LogLog.debug("deleting existing target file: " + target);
+ target.delete();
+ }
+
+ File file = new File(from);
+ file.renameTo(target);
+ LogLog.debug(from +" -> "+ to);
+ }
+
+ /** Delete's the specified file if it exists */
+ protected static void deleteFile(String fileName) {
+ File file = new File(fileName);
+ if (file.exists()) {
+ file.delete();
+ }
+ }
+
+ /**
+ Implements roll overs base on file size.
+
+ <p>If the maximum number of size based backups is reached
+ (<code>curSizeRollBackups == maxSizeRollBackups</code) then the oldest
+ file is deleted -- it's index determined by the sign of countDirection.<br>
+ If <code>countDirection</code> < 0, then files
+ {<code>File.1</code>, ..., <code>File.curSizeRollBackups -1</code>}
+ are renamed to {<code>File.2</code>, ...,
+ <code>File.curSizeRollBackups</code>}. Moreover, <code>File</code> is
+ renamed <code>File.1</code> and closed.<br>
+
+ A new file is created to receive further log output.
+
+ <p>If <code>maxSizeRollBackups</code> is equal to zero, then the
+ <code>File</code> is truncated with no backup files created.
+
+ <p>If <code>maxSizeRollBackups</code> < 0, then <code>File</code> is
+ renamed if needed and no files are deleted.
+ */
+
+ // synchronization not necessary since doAppend is alreasy synched
+ protected void rollOverSize() {
+ File file;
+
+ this.closeFile(); // keep windows happy.
+
+ LogLog.debug("rolling over count=" + ((CountingQuietWriter) qw).getCount());
+ LogLog.debug("maxSizeRollBackups = " + maxSizeRollBackups);
+ LogLog.debug("curSizeRollBackups = " + curSizeRollBackups);
+ LogLog.debug("countDirection = " + countDirection);
+
+ // If maxBackups <= 0, then there is no file renaming to be done.
+ if (maxSizeRollBackups != 0) {
+
+ if (countDirection < 0) {
+ // Delete the oldest file, to keep Windows happy.
+ if (curSizeRollBackups == maxSizeRollBackups) {
+ deleteFile(fileName + '.' + maxSizeRollBackups);
+ curSizeRollBackups--;
+ }
+
+ // Map {(maxBackupIndex - 1), ..., 2, 1} to {maxBackupIndex, ..., 3, 2}
+ for (int i = curSizeRollBackups; i >= 1; i--) {
+ rollFile((fileName + "." + i), (fileName + '.' + (i + 1)));
+ }
+
+ curSizeRollBackups++;
+ // Rename fileName to fileName.1
+ rollFile(fileName, fileName + ".1");
+
+ } //REMOVE This code branching for Alexander Cerna's request
+ else if (countDirection == 0) {
+ //rollFile based on date pattern
+ curSizeRollBackups++;
+ now.setTime(System.currentTimeMillis());
+ scheduledFilename = fileName + sdf.format(now);
+ rollFile(fileName, scheduledFilename);
+ }
+ else { //countDirection > 0
+ if (curSizeRollBackups >= maxSizeRollBackups && maxSizeRollBackups > 0) {
+ //delete the first and keep counting up.
+ int oldestFileIndex = curSizeRollBackups - maxSizeRollBackups + 1;
+ deleteFile(fileName + '.' + oldestFileIndex);
+ }
+
+ if (staticLogFileName) {
+ curSizeRollBackups++;
+ rollFile(fileName, fileName + '.' + curSizeRollBackups);
+ }
+ }
+ }
+
+ try {
+ // This will also close the file. This is OK since multiple
+ // close operations are safe.
+ this.setFile(baseFileName, false);
+ }
+ catch(IOException e) {
+ LogLog.error("setFile("+fileName+", false) call failed.", e);
+ }
+ }
+
+}
Propchange: incubator/qpid/branches/M2/java/broker/src/main/java/org/apache/log4j/QpidCompositeRollingAppender.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/qpid/branches/M2/java/broker/src/main/java/org/apache/log4j/QpidCompositeRollingAppender.java
------------------------------------------------------------------------------
svn:keywords = Rev Date