001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache license, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the license for the specific language governing permissions and 015 * limitations under the license. 016 */ 017package org.apache.logging.log4j.core.appender; 018 019import java.io.BufferedOutputStream; 020import java.io.File; 021import java.io.FileNotFoundException; 022import java.io.FileOutputStream; 023import java.io.IOException; 024import java.io.OutputStream; 025import java.io.Serializable; 026import java.nio.channels.FileChannel; 027import java.nio.channels.FileLock; 028import java.util.HashMap; 029import java.util.Map; 030 031import org.apache.logging.log4j.core.Layout; 032 033 034/** 035 * Manages actual File I/O for File Appenders. 036 */ 037public class FileManager extends OutputStreamManager { 038 039 private static final FileManagerFactory FACTORY = new FileManagerFactory(); 040 041 private final boolean isAppend; 042 private final boolean isLocking; 043 private final String advertiseURI; 044 045 protected FileManager(final String fileName, final OutputStream os, final boolean append, final boolean locking, 046 final String advertiseURI, final Layout<? extends Serializable> layout) { 047 super(os, fileName, layout); 048 this.isAppend = append; 049 this.isLocking = locking; 050 this.advertiseURI = advertiseURI; 051 } 052 053 /** 054 * Returns the FileManager. 055 * @param fileName The name of the file to manage. 056 * @param append true if the file should be appended to, false if it should be overwritten. 057 * @param locking true if the file should be locked while writing, false otherwise. 058 * @param bufferedIO true if the contents should be buffered as they are written. 059 * @param advertiseURI the URI to use when advertising the file 060 * @param layout The layout 061 * @param bufferSize buffer size for buffered IO 062 * @return A FileManager for the File. 063 */ 064 public static FileManager getFileManager(final String fileName, final boolean append, boolean locking, 065 final boolean bufferedIO, final String advertiseURI, final Layout<? extends Serializable> layout, 066 final int bufferSize) { 067 068 if (locking && bufferedIO) { 069 locking = false; 070 } 071 return (FileManager) getManager(fileName, new FactoryData(append, locking, bufferedIO, bufferSize, 072 advertiseURI, layout), FACTORY); 073 } 074 075 @Override 076 protected synchronized void write(final byte[] bytes, final int offset, final int length) { 077 078 if (isLocking) { 079 final FileChannel channel = ((FileOutputStream) getOutputStream()).getChannel(); 080 try { 081 /* Lock the whole file. This could be optimized to only lock from the current file 082 position. Note that locking may be advisory on some systems and mandatory on others, 083 so locking just from the current position would allow reading on systems where 084 locking is mandatory. Also, Java 6 will throw an exception if the region of the 085 file is already locked by another FileChannel in the same JVM. Hopefully, that will 086 be avoided since every file should have a single file manager - unless two different 087 files strings are configured that somehow map to the same file.*/ 088 final FileLock lock = channel.lock(0, Long.MAX_VALUE, false); 089 try { 090 super.write(bytes, offset, length); 091 } finally { 092 lock.release(); 093 } 094 } catch (final IOException ex) { 095 throw new AppenderLoggingException("Unable to obtain lock on " + getName(), ex); 096 } 097 098 } else { 099 super.write(bytes, offset, length); 100 } 101 } 102 103 /** 104 * Returns the name of the File being managed. 105 * @return The name of the File being managed. 106 */ 107 public String getFileName() { 108 return getName(); 109 } 110 111 /** 112 * Returns the append status. 113 * @return true if the file will be appended to, false if it is overwritten. 114 */ 115 public boolean isAppend() { 116 return isAppend; 117 } 118 119 /** 120 * Returns the lock status. 121 * @return true if the file will be locked when writing, false otherwise. 122 */ 123 public boolean isLocking() { 124 return isLocking; 125 } 126 127 /** 128 * FileManager's content format is specified by: <code>Key: "fileURI" Value: provided "advertiseURI" param</code>. 129 * 130 * @return Map of content format keys supporting FileManager 131 */ 132 @Override 133 public Map<String, String> getContentFormat() { 134 final Map<String, String> result = new HashMap<String, String>(super.getContentFormat()); 135 result.put("fileURI", advertiseURI); 136 return result; 137 } 138 139 /** 140 * Factory Data. 141 */ 142 private static class FactoryData { 143 private final boolean append; 144 private final boolean locking; 145 private final boolean bufferedIO; 146 private final int bufferSize; 147 private final String advertiseURI; 148 private final Layout<? extends Serializable> layout; 149 150 /** 151 * Constructor. 152 * @param append Append status. 153 * @param locking Locking status. 154 * @param bufferedIO Buffering flag. 155 * @param bufferSize Buffer size. 156 * @param advertiseURI the URI to use when advertising the file 157 */ 158 public FactoryData(final boolean append, final boolean locking, final boolean bufferedIO, final int bufferSize, 159 final String advertiseURI, final Layout<? extends Serializable> layout) { 160 this.append = append; 161 this.locking = locking; 162 this.bufferedIO = bufferedIO; 163 this.bufferSize = bufferSize; 164 this.advertiseURI = advertiseURI; 165 this.layout = layout; 166 } 167 } 168 169 /** 170 * Factory to create a FileManager. 171 */ 172 private static class FileManagerFactory implements ManagerFactory<FileManager, FactoryData> { 173 174 /** 175 * Create a FileManager. 176 * @param name The name of the File. 177 * @param data The FactoryData 178 * @return The FileManager for the File. 179 */ 180 @Override 181 public FileManager createManager(final String name, final FactoryData data) { 182 final File file = new File(name); 183 final File parent = file.getParentFile(); 184 if (null != parent && !parent.exists()) { 185 parent.mkdirs(); 186 } 187 188 OutputStream os; 189 try { 190 os = new FileOutputStream(name, data.append); 191 if (data.bufferedIO) { 192 os = new BufferedOutputStream(os, data.bufferSize); 193 } 194 return new FileManager(name, os, data.append, data.locking, data.advertiseURI, data.layout); 195 } catch (final FileNotFoundException ex) { 196 LOGGER.error("FileManager (" + name + ") " + ex); 197 } 198 return null; 199 } 200 } 201 202}