/*
* 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.infinispan.util.logging.log4j;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.zip.GZIPOutputStream;
import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.appender.FileManager;
import org.apache.logging.log4j.core.appender.ManagerFactory;
/**
* Manages actual File I/O for the CompressedFileAppender.
*/
public class CompressedFileManager extends FileManager {
protected CompressedFileManager(String fileName, OutputStream os, boolean append, boolean locking, String advertiseURI, Layout<? extends Serializable> layout, int bufferSize, boolean writerHeader) {
super(fileName, os, append, locking, advertiseURI, layout, bufferSize, writerHeader);
}
private static final CompressedFileManagerFactory FACTORY = new CompressedFileManagerFactory();
/**
* Returns the FileManager.
*
* @param fileName
* The name of the file to manage.
* @param append
* true if the file should be appended to, false if it should be overwritten.
* @param locking
* true if the file should be locked while writing, false otherwise.
* @param bufferedIo
* true if the contents should be buffered as they are written.
* @param advertiseUri
* the URI to use when advertising the file
* @param layout
* The layout
* @param bufferSize
* buffer size for buffered IO
* @return A FileManager for the File.
*/
public static CompressedFileManager getFileManager(final String fileName, final boolean append, boolean locking, final boolean bufferedIo, final String advertiseUri,
final Layout<? extends Serializable> layout, final int bufferSize) {
if (locking && bufferedIo) {
locking = false;
}
return (CompressedFileManager) getManager(fileName, new FactoryData(append, locking, bufferedIo, bufferSize, advertiseUri, layout), FACTORY);
}
/**
* Factory Data.
*/
private static class FactoryData {
private final boolean append;
private final boolean locking;
private final boolean bufferedIO;
private final int bufferSize;
private final String advertiseURI;
private final Layout<? extends Serializable> layout;
/**
* Constructor.
*
* @param append
* Append status.
* @param locking
* Locking status.
* @param bufferedIO
* Buffering flag.
* @param bufferSize
* Buffer size.
* @param advertiseURI
* the URI to use when advertising the file
*/
public FactoryData(final boolean append, final boolean locking, final boolean bufferedIO, final int bufferSize, final String advertiseURI,
final Layout<? extends Serializable> layout) {
this.append = append;
this.locking = locking;
this.bufferedIO = bufferedIO;
this.bufferSize = bufferSize;
this.advertiseURI = advertiseURI;
this.layout = layout;
}
}
/**
* Factory to create a FileManager.
*/
private static class CompressedFileManagerFactory implements ManagerFactory<CompressedFileManager, FactoryData> {
/**
* Create a FileManager.
*
* @param name
* The name of the File.
* @param data
* The FactoryData
* @return The FileManager for the File.
*/
@Override
public CompressedFileManager createManager(final String name, final FactoryData data) {
final File file = new File(name);
final File parent = file.getParentFile();
if (null != parent && !parent.exists()) {
parent.mkdirs();
}
OutputStream os;
try {
os = new FileOutputStream(name, data.append);
int bufferSize = data.bufferSize;
if (name.endsWith(".gz")) {
os = new GZIPOutputStream(os, bufferSize, true);
os.flush();
} else {
if (data.bufferedIO) {
os = new BufferedOutputStream(os, bufferSize);
} else {
bufferSize = -1; // signals to RollingFileManager not to use BufferedOutputStream
}
}
boolean writeHeader = !data.append || !file.exists();
return new CompressedFileManager(name, os, data.append, data.locking, data.advertiseURI, data.layout, bufferSize, writeHeader);
} catch (final IOException ex) {
LOGGER.error("FileManager (" + name + ") " + ex);
}
return null;
}
}
}