log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RollingRandomAccessFileAppender.java - logging-log4j2 - Git at Google

 /*
  * 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.logging.log4j.core.appender;

 import org.apache.logging.log4j.core.Appender;
 import org.apache.logging.log4j.core.Core;
 import org.apache.logging.log4j.core.Filter;
 import org.apache.logging.log4j.core.Layout;
 import org.apache.logging.log4j.core.LogEvent;
 import org.apache.logging.log4j.core.appender.rolling.DefaultRolloverStrategy;
 import org.apache.logging.log4j.core.appender.rolling.DirectFileRolloverStrategy;
 import org.apache.logging.log4j.core.appender.rolling.DirectWriteRolloverStrategy;
 import org.apache.logging.log4j.core.appender.rolling.RollingRandomAccessFileManager;
 import org.apache.logging.log4j.core.appender.rolling.RolloverStrategy;
 import org.apache.logging.log4j.core.appender.rolling.TriggeringPolicy;
 import org.apache.logging.log4j.core.net.Advertiser;
 import org.apache.logging.log4j.plugins.Plugin;
 import org.apache.logging.log4j.plugins.PluginBuilderAttribute;
 import org.apache.logging.log4j.plugins.PluginElement;
 import org.apache.logging.log4j.plugins.PluginFactory;

 import java.io.Serializable;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import java.util.zip.Deflater;

 /**
  * An appender that writes to random access files and can roll over at
  * intervals.
  */
 @Plugin(name = "RollingRandomAccessFile", category = Core.CATEGORY_NAME, elementType = Appender.ELEMENT_TYPE, printObject = true)
 public final class RollingRandomAccessFileAppender extends AbstractOutputStreamAppender<RollingRandomAccessFileManager> {

     public static class Builder<B extends Builder<B>> extends AbstractOutputStreamAppender.Builder<B>
             implements org.apache.logging.log4j.plugins.util.Builder<RollingRandomAccessFileAppender> {

         public Builder() {
             super();
             setBufferSize(RollingRandomAccessFileManager.DEFAULT_BUFFER_SIZE);
             setIgnoreExceptions(true);
             setImmediateFlush(true);
         }

         @PluginBuilderAttribute("fileName")
         private String fileName;

         @PluginBuilderAttribute("filePattern")
         private String filePattern;

         @PluginBuilderAttribute("append")
         private boolean append = true;

         @PluginElement("Policy")
         private TriggeringPolicy policy;

         @PluginElement("Strategy")
         private RolloverStrategy strategy;

         @PluginBuilderAttribute("advertise")
         private boolean advertise;

         @PluginBuilderAttribute("advertiseURI")
         private String advertiseURI;

         @PluginBuilderAttribute
         private String filePermissions;

         @PluginBuilderAttribute
         private String fileOwner;

         @PluginBuilderAttribute
         private String fileGroup;

         @Override
         public RollingRandomAccessFileAppender build() {
             final String name = getName();
             if (name == null) {
                 LOGGER.error("No name provided for FileAppender");
                 return null;
             }

             if (strategy == null) {
                 if (fileName != null) {
                     strategy = DefaultRolloverStrategy.newBuilder()
                             .setCompressionLevelStr(String.valueOf(Deflater.DEFAULT_COMPRESSION))
                             .setConfig(getConfiguration())
                             .build();
                 } else {
                     strategy = DirectWriteRolloverStrategy.newBuilder()
                             .setCompressionLevelStr(String.valueOf(Deflater.DEFAULT_COMPRESSION))
                             .setConfig(getConfiguration())
                             .build();
                 }
             } else if (fileName == null && !(strategy instanceof DirectFileRolloverStrategy)) {
                 LOGGER.error("RollingFileAppender '{}': When no file name is provided a DirectFileRolloverStrategy must be configured", name);
                 return null;
             }

             if (filePattern == null) {
                 LOGGER.error("No filename pattern provided for FileAppender with name " + name);
                 return null;
             }

             if (policy == null) {
                 LOGGER.error("A TriggeringPolicy must be provided");
                 return null;
             }

             final Layout<? extends Serializable> layout = getOrCreateLayout();

             final boolean immediateFlush = isImmediateFlush();
             final int bufferSize = getBufferSize();
             final RollingRandomAccessFileManager manager = RollingRandomAccessFileManager
                     .getRollingRandomAccessFileManager(fileName, filePattern, append, immediateFlush, bufferSize, policy,
                             strategy, advertiseURI, layout,
                             filePermissions, fileOwner, fileGroup, getConfiguration());
             if (manager == null) {
                 return null;
             }

             manager.initialize();

             return new RollingRandomAccessFileAppender(name, layout,getFilter(), manager, fileName, filePattern,
                     isIgnoreExceptions(), immediateFlush, bufferSize, advertise ? getConfiguration().getAdvertiser() : null);
         }

         public B setFileName(final String fileName) {
             this.fileName = fileName;
             return asBuilder();
         }

         public B setFilePattern(final String filePattern) {
             this.filePattern = filePattern;
             return asBuilder();
         }

         public B setAppend(final boolean append) {
             this.append = append;
             return asBuilder();
         }

         public B setPolicy(final TriggeringPolicy policy) {
             this.policy = policy;
             return asBuilder();
         }

         public B setStrategy(final RolloverStrategy strategy) {
             this.strategy = strategy;
             return asBuilder();
         }

         public B setAdvertise(final boolean advertise) {
             this.advertise = advertise;
             return asBuilder();
         }

         public B setAdvertiseURI(final String advertiseURI) {
             this.advertiseURI = advertiseURI;
             return asBuilder();
         }

         public B setFilePermissions(final String filePermissions) {
             this.filePermissions = filePermissions;
             return asBuilder();
         }

         public B setFileOwner(final String fileOwner) {
             this.fileOwner = fileOwner;
             return asBuilder();
         }

         public B setFileGroup(final String fileGroup) {
             this.fileGroup = fileGroup;
             return asBuilder();
         }

     }

     private final String fileName;
     private final String filePattern;
     private final Object advertisement;
     private final Advertiser advertiser;

     private RollingRandomAccessFileAppender(final String name, final Layout<? extends Serializable> layout,
             final Filter filter, final RollingRandomAccessFileManager manager, final String fileName,
             final String filePattern, final boolean ignoreExceptions,
             final boolean immediateFlush, final int bufferSize, final Advertiser advertiser) {
         super(name, layout, filter, ignoreExceptions, immediateFlush, null, manager);
         if (advertiser != null) {
             final Map<String, String> configuration = new HashMap<>(layout.getContentFormat());
             configuration.put("contentType", layout.getContentType());
             configuration.put("name", name);
             advertisement = advertiser.advertise(configuration);
         } else {
             advertisement = null;
         }
         this.fileName = fileName;
         this.filePattern = filePattern;
         this.advertiser = advertiser;
     }

     @Override
     public boolean stop(final long timeout, final TimeUnit timeUnit) {
         setStopping();
         super.stop(timeout, timeUnit, false);
         if (advertiser != null) {
             advertiser.unadvertise(advertisement);
         }
         setStopped();
         return true;
     }

     /**
      * Write the log entry rolling over the file when required.
      *
      * @param event The LogEvent.
      */
     @Override
     public void append(final LogEvent event) {
         final RollingRandomAccessFileManager manager = getManager();
         manager.checkRollover(event);

         // Leverage the nice batching behaviour of async Loggers/Appenders:
         // we can signal the file manager that it needs to flush the buffer
         // to disk at the end of a batch.
         // From a user's point of view, this means that all log events are
         // _always_ available in the log file, without incurring the overhead
         // of immediateFlush=true.
         manager.setEndOfBatch(event.isEndOfBatch()); // FIXME manager's EndOfBatch threadlocal can be deleted

         // LOG4J2-1292 utilize gc-free Layout.encode() method: taken care of in superclass
         super.append(event);
     }

     /**
      * Returns the File name for the Appender.
      *
      * @return The file name.
      */
     public String getFileName() {
         return fileName;
     }

     /**
      * Returns the file pattern used when rolling over.
      *
      * @return The file pattern.
      */
     public String getFilePattern() {
         return filePattern;
     }

     /**
      * Returns the size of the file manager's buffer.
      * @return the buffer size
      */
     public int getBufferSize() {
         return getManager().getBufferSize();
     }

     @PluginFactory
     public static <B extends Builder<B>> B newBuilder() {
         return new Builder<B>().asBuilder();
     }

 }
	/*
	* 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.logging.log4j.core.appender;

	import org.apache.logging.log4j.core.Appender;
	import org.apache.logging.log4j.core.Core;
	import org.apache.logging.log4j.core.Filter;
	import org.apache.logging.log4j.core.Layout;
	import org.apache.logging.log4j.core.LogEvent;
	import org.apache.logging.log4j.core.appender.rolling.DefaultRolloverStrategy;
	import org.apache.logging.log4j.core.appender.rolling.DirectFileRolloverStrategy;
	import org.apache.logging.log4j.core.appender.rolling.DirectWriteRolloverStrategy;
	import org.apache.logging.log4j.core.appender.rolling.RollingRandomAccessFileManager;
	import org.apache.logging.log4j.core.appender.rolling.RolloverStrategy;
	import org.apache.logging.log4j.core.appender.rolling.TriggeringPolicy;
	import org.apache.logging.log4j.core.net.Advertiser;
	import org.apache.logging.log4j.plugins.Plugin;
	import org.apache.logging.log4j.plugins.PluginBuilderAttribute;
	import org.apache.logging.log4j.plugins.PluginElement;
	import org.apache.logging.log4j.plugins.PluginFactory;

	import java.io.Serializable;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.concurrent.TimeUnit;
	import java.util.zip.Deflater;

	/**
	* An appender that writes to random access files and can roll over at
	* intervals.
	*/
	@Plugin(name = "RollingRandomAccessFile", category = Core.CATEGORY_NAME, elementType = Appender.ELEMENT_TYPE, printObject = true)
	public final class RollingRandomAccessFileAppender extends AbstractOutputStreamAppender<RollingRandomAccessFileManager> {

	public static class Builder<B extends Builder<B>> extends AbstractOutputStreamAppender.Builder<B>
	implements org.apache.logging.log4j.plugins.util.Builder<RollingRandomAccessFileAppender> {

	public Builder() {
	super();
	setBufferSize(RollingRandomAccessFileManager.DEFAULT_BUFFER_SIZE);
	setIgnoreExceptions(true);
	setImmediateFlush(true);
	}

	@PluginBuilderAttribute("fileName")
	private String fileName;

	@PluginBuilderAttribute("filePattern")
	private String filePattern;

	@PluginBuilderAttribute("append")
	private boolean append = true;

	@PluginElement("Policy")
	private TriggeringPolicy policy;

	@PluginElement("Strategy")
	private RolloverStrategy strategy;

	@PluginBuilderAttribute("advertise")
	private boolean advertise;

	@PluginBuilderAttribute("advertiseURI")
	private String advertiseURI;

	@PluginBuilderAttribute
	private String filePermissions;

	@PluginBuilderAttribute
	private String fileOwner;

	@PluginBuilderAttribute
	private String fileGroup;

	@Override
	public RollingRandomAccessFileAppender build() {
	final String name = getName();
	if (name == null) {
	LOGGER.error("No name provided for FileAppender");
	return null;
	}

	if (strategy == null) {
	if (fileName != null) {
	strategy = DefaultRolloverStrategy.newBuilder()
	.setCompressionLevelStr(String.valueOf(Deflater.DEFAULT_COMPRESSION))
	.setConfig(getConfiguration())
	.build();
	} else {
	strategy = DirectWriteRolloverStrategy.newBuilder()
	.setCompressionLevelStr(String.valueOf(Deflater.DEFAULT_COMPRESSION))
	.setConfig(getConfiguration())
	.build();
	}
	} else if (fileName == null && !(strategy instanceof DirectFileRolloverStrategy)) {
	LOGGER.error("RollingFileAppender '{}': When no file name is provided a DirectFileRolloverStrategy must be configured", name);
	return null;
	}

	if (filePattern == null) {
	LOGGER.error("No filename pattern provided for FileAppender with name " + name);
	return null;
	}

	if (policy == null) {
	LOGGER.error("A TriggeringPolicy must be provided");
	return null;
	}

	final Layout<? extends Serializable> layout = getOrCreateLayout();

	final boolean immediateFlush = isImmediateFlush();
	final int bufferSize = getBufferSize();
	final RollingRandomAccessFileManager manager = RollingRandomAccessFileManager
	.getRollingRandomAccessFileManager(fileName, filePattern, append, immediateFlush, bufferSize, policy,
	strategy, advertiseURI, layout,
	filePermissions, fileOwner, fileGroup, getConfiguration());
	if (manager == null) {
	return null;
	}

	manager.initialize();

	return new RollingRandomAccessFileAppender(name, layout,getFilter(), manager, fileName, filePattern,
	isIgnoreExceptions(), immediateFlush, bufferSize, advertise ? getConfiguration().getAdvertiser() : null);
	}

	public B setFileName(final String fileName) {
	this.fileName = fileName;
	return asBuilder();
	}

	public B setFilePattern(final String filePattern) {
	this.filePattern = filePattern;
	return asBuilder();
	}

	public B setAppend(final boolean append) {
	this.append = append;
	return asBuilder();
	}

	public B setPolicy(final TriggeringPolicy policy) {
	this.policy = policy;
	return asBuilder();
	}

	public B setStrategy(final RolloverStrategy strategy) {
	this.strategy = strategy;
	return asBuilder();
	}

	public B setAdvertise(final boolean advertise) {
	this.advertise = advertise;
	return asBuilder();
	}

	public B setAdvertiseURI(final String advertiseURI) {
	this.advertiseURI = advertiseURI;
	return asBuilder();
	}

	public B setFilePermissions(final String filePermissions) {
	this.filePermissions = filePermissions;
	return asBuilder();
	}

	public B setFileOwner(final String fileOwner) {
	this.fileOwner = fileOwner;
	return asBuilder();
	}

	public B setFileGroup(final String fileGroup) {
	this.fileGroup = fileGroup;
	return asBuilder();
	}

	}

	private final String fileName;
	private final String filePattern;
	private final Object advertisement;
	private final Advertiser advertiser;

	private RollingRandomAccessFileAppender(final String name, final Layout<? extends Serializable> layout,
	final Filter filter, final RollingRandomAccessFileManager manager, final String fileName,
	final String filePattern, final boolean ignoreExceptions,
	final boolean immediateFlush, final int bufferSize, final Advertiser advertiser) {
	super(name, layout, filter, ignoreExceptions, immediateFlush, null, manager);
	if (advertiser != null) {
	final Map<String, String> configuration = new HashMap<>(layout.getContentFormat());
	configuration.put("contentType", layout.getContentType());
	configuration.put("name", name);
	advertisement = advertiser.advertise(configuration);
	} else {
	advertisement = null;
	}
	this.fileName = fileName;
	this.filePattern = filePattern;
	this.advertiser = advertiser;
	}

	@Override
	public boolean stop(final long timeout, final TimeUnit timeUnit) {
	setStopping();
	super.stop(timeout, timeUnit, false);
	if (advertiser != null) {
	advertiser.unadvertise(advertisement);
	}
	setStopped();
	return true;
	}

	/**
	* Write the log entry rolling over the file when required.
	*
	* @param event The LogEvent.
	*/
	@Override
	public void append(final LogEvent event) {
	final RollingRandomAccessFileManager manager = getManager();
	manager.checkRollover(event);

	// Leverage the nice batching behaviour of async Loggers/Appenders:
	// we can signal the file manager that it needs to flush the buffer
	// to disk at the end of a batch.
	// From a user's point of view, this means that all log events are
	// _always_ available in the log file, without incurring the overhead
	// of immediateFlush=true.
	manager.setEndOfBatch(event.isEndOfBatch()); // FIXME manager's EndOfBatch threadlocal can be deleted

	// LOG4J2-1292 utilize gc-free Layout.encode() method: taken care of in superclass
	super.append(event);
	}

	/**
	* Returns the File name for the Appender.
	*
	* @return The file name.
	*/
	public String getFileName() {
	return fileName;
	}

	/**
	* Returns the file pattern used when rolling over.
	*
	* @return The file pattern.
	*/
	public String getFilePattern() {
	return filePattern;
	}

	/**
	* Returns the size of the file manager's buffer.
	* @return the buffer size
	*/
	public int getBufferSize() {
	return getManager().getBufferSize();
	}

	@PluginFactory
	public static <B extends Builder<B>> B newBuilder() {
	return new Builder<B>().asBuilder();
	}

	}