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 */ 017 package org.apache.geronimo.jetty6.requestlog; 018 019 import java.io.File; 020 import java.io.FilenameFilter; 021 import java.io.RandomAccessFile; 022 import java.nio.CharBuffer; 023 import java.nio.MappedByteBuffer; 024 import java.nio.channels.FileChannel; 025 import java.nio.charset.Charset; 026 import java.text.ParseException; 027 import java.text.SimpleDateFormat; 028 import java.util.ArrayList; 029 import java.util.Collection; 030 import java.util.Date; 031 import java.util.Iterator; 032 import java.util.LinkedList; 033 import java.util.List; 034 import java.util.regex.Matcher; 035 import java.util.regex.Pattern; 036 037 import org.apache.commons.logging.Log; 038 import org.apache.commons.logging.LogFactory; 039 import org.apache.geronimo.gbean.GBeanInfo; 040 import org.apache.geronimo.gbean.GBeanInfoBuilder; 041 import org.apache.geronimo.system.serverinfo.ServerInfo; 042 043 /** 044 * Jetty implementation of the WebAccessLog management interface. 045 * 046 * @version $Rev: 482336 $ $Date: 2006-12-04 15:12:19 -0500 (Mon, 04 Dec 2006) $ 047 */ 048 public class JettyLogManagerImpl implements JettyLogManager { 049 private final static Log log = LogFactory.getLog(JettyLogManagerImpl.class); 050 051 // Pattern that matches the date in the logfile name 052 private final static Pattern FILENAME_DATE_PATTERN = Pattern.compile("[-_ /.](((19|20)\\d\\d)[-_ /.](0[1-9]|1[012])[-_ /.](0[1-9]|[12][0-9]|3[01]))"); 053 private final static int GROUP_FILENAME_FULL_DATE = 1; 054 private final static int GROUP_FILENAME_YEAR = 2; 055 private final static int GROUP_FILENAME_MONTH = 4; 056 private final static int GROUP_FILENAME_DAY = 5; 057 // NOTE: The file separators are specified here rather than using something like File.separator because 058 // they are hard coded in config plans and sometimes in java code itself rather than being dependent 059 // upon the OS. This should be fixed someday, but for now we will manually check for either format. 060 private final static String FILE_SEPARATOR_UNIX_STYLE = "/"; 061 private final static String FILE_SEPARATOR_WIN_STYLE = "\\"; 062 063 // Pattern that matches a single line (used to calculate line numbers) 064 private final static Pattern FULL_LINE_PATTERN = Pattern.compile("^.*", Pattern.MULTILINE); 065 private final static Pattern ACCESS_LOG_PATTERN = Pattern.compile("(\\S*) (\\S*) (\\S*) \\[(.*)\\] \\\"(\\S*) (\\S*).*?\\\" (\\S*) (\\S*).*"); 066 private final static int GROUP_HOST = 1; 067 private final static int GROUP_USER = 3; 068 private final static int GROUP_DATE = 4; 069 private final static int GROUP_METHOD = 5; 070 private final static int GROUP_URI = 6; 071 private final static int GROUP_RESPONSE_CODE = 7; 072 private final static int GROUP_RESPONSE_LENGTH = 8; 073 private final static String ACCESS_LOG_DATE_FORMAT = "dd/MMM/yyyy:HH:mm:ss ZZZZ"; 074 private final static String LOG_FILE_NAME_FORMAT = "yyyy_MM_dd"; 075 private final Collection logGbeans; 076 private final ServerInfo serverInfo; 077 078 public JettyLogManagerImpl(ServerInfo serverInfo, Collection logGbeans) { 079 this.serverInfo = serverInfo; 080 this.logGbeans = logGbeans; 081 } 082 083 /** 084 * Gets the name of all logs used by this system. Typically there 085 * is only one, but specialized cases may use more. 086 * 087 * @return An array of all log names 088 * 089 */ 090 public String[] getLogNames() { 091 List logNames = new ArrayList(); 092 for (Iterator it = logGbeans.iterator(); it.hasNext();) { 093 JettyRequestLog jettyLog = (JettyRequestLog) it.next(); 094 if(jettyLog.getFilename() != null) { 095 logNames.add(jettyLog.getFilename()); 096 } 097 } 098 return (String[]) logNames.toArray(new String[logNames.size()]); 099 } 100 101 /** 102 * Gets the names of all log files for this log name. 103 * 104 * @param logName The name of the log for which to return the specific file names. 105 * 106 * @return An array of log file names 107 * 108 */ 109 public String[] getLogFileNames(String logName) { 110 List names = new ArrayList(); 111 112 // Find all the files for this logName 113 File[] logFiles = getLogFiles(logName); 114 115 if (logFiles !=null) { 116 for (int i = 0; i < logFiles.length; i++) { 117 names.add(logFiles[i].getName()); 118 } 119 } 120 return (String[]) names.toArray(new String[names.size()]); 121 } 122 123 /** 124 * Gets the name of all log files used by this log. Typically there 125 * is only one, but specialized cases may use more. 126 * 127 * @param logName The name of the log for which to return the specific files. 128 * 129 * @return An array of all log file names 130 * 131 */ 132 private File[] getLogFiles(String logName) { 133 File[] logFiles = null; 134 135 try { 136 String fileNamePattern = logName; 137 if (fileNamePattern.indexOf(FILE_SEPARATOR_UNIX_STYLE) > -1) { 138 fileNamePattern = fileNamePattern.substring(fileNamePattern.lastIndexOf(FILE_SEPARATOR_UNIX_STYLE) + 1); 139 } else if (fileNamePattern.indexOf(FILE_SEPARATOR_WIN_STYLE) > -1) { 140 fileNamePattern = fileNamePattern.substring(fileNamePattern.lastIndexOf(FILE_SEPARATOR_WIN_STYLE) + 1); 141 } 142 143 String logFile = serverInfo.resolvePath(logName); 144 145 File parent = new File(logFile).getParentFile(); 146 147 if (parent != null) { 148 logFiles = parent.listFiles(new PatternFilenameFilter(fileNamePattern)); 149 } 150 } catch (Exception e) { 151 log.error("Exception attempting to locate Jetty log files", e); 152 logFiles = new File[0]; 153 } 154 return logFiles; 155 } 156 157 /** 158 * Searches the log for records matching the specified parameters. The 159 * maximum results returned will be the lesser of 1000 and the 160 * provided maxResults argument. 161 * 162 * @see #MAX_SEARCH_RESULTS 163 */ 164 public SearchResults getMatchingItems(String logName, String host, String user, String method, String uri, Date startDate, 165 Date endDate, Integer skipResults, Integer maxResults) { 166 167 // Clean up the arguments so we know what we've really got 168 if(host != null && host.equals("")) host = null; 169 if(user != null && user.equals("")) user = null; 170 if(method != null && method.equals("")) method = null; 171 if(uri != null && uri.equals("")) uri = null; 172 173 long start = startDate == null ? 0 : startDate.getTime(); 174 long end = endDate == null ? 0 : endDate.getTime(); 175 176 List list = new LinkedList(); 177 boolean capped = false; 178 int lineCount = 0, fileCount = 0; 179 180 // Find all the files for this logName 181 File logFiles[] = getLogFiles(logName); 182 183 if (logFiles !=null) { 184 for (int i = 0; i < logFiles.length; i++) { 185 fileCount = 0; 186 try { 187 // Obtain the date for the current log file 188 String fileName = logFiles[i].getName(); 189 Matcher fileDate = FILENAME_DATE_PATTERN.matcher(fileName); 190 fileDate.find(); 191 SimpleDateFormat simpleFileDate = new SimpleDateFormat(LOG_FILE_NAME_FORMAT); 192 long logFileTime = simpleFileDate.parse(fileDate.group(GROUP_FILENAME_FULL_DATE)).getTime(); 193 194 // Check if the dates are null (ignore) or fall within the search range 195 if ( (start==0 && end==0) 196 || (start>0 && start<=logFileTime && end>0 && end>=logFileTime)) { 197 198 // It's in the range, so process the file 199 RandomAccessFile raf = new RandomAccessFile(logFiles[i], "r"); 200 FileChannel fc = raf.getChannel(); 201 MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size()); 202 CharBuffer cb = Charset.forName("US-ASCII").decode(bb); //todo: does Jetty use a different charset on a foreign PC? 203 Matcher lines = FULL_LINE_PATTERN.matcher(cb); 204 Matcher target = ACCESS_LOG_PATTERN.matcher(""); 205 SimpleDateFormat format = (start == 0 && end == 0) ? null : new SimpleDateFormat(ACCESS_LOG_DATE_FORMAT); 206 int max = maxResults == null ? MAX_SEARCH_RESULTS : Math.min(maxResults.intValue(), MAX_SEARCH_RESULTS); 207 208 while(lines.find()) { 209 ++lineCount; 210 ++fileCount; 211 if(capped) { 212 continue; 213 } 214 CharSequence line = cb.subSequence(lines.start(), lines.end()); 215 target.reset(line); 216 if(target.find()) { 217 if(host != null && !host.equals(target.group(GROUP_HOST))) { 218 continue; 219 } 220 if(user != null && !user.equals(target.group(GROUP_USER))) { 221 continue; 222 } 223 if(method != null && !method.equals(target.group(GROUP_METHOD))) { 224 continue; 225 } 226 if(uri != null && !target.group(GROUP_URI).startsWith(uri)) { 227 continue; 228 } 229 if(format != null) { 230 try { 231 long entry = format.parse(target.group(GROUP_DATE)).getTime(); 232 if(start > entry) { 233 continue; 234 } 235 if(end > 0 && end < entry) { 236 continue; 237 } 238 } catch (ParseException e) { 239 // can't read the date, guess this record counts. 240 } 241 } 242 if(skipResults != null && skipResults.intValue() > lineCount) { 243 continue; 244 } 245 if(list.size() > max) { 246 capped = true; 247 continue; 248 } 249 list.add(new LogMessage(fileCount,line.toString())); 250 } 251 } 252 fc.close(); 253 raf.close(); 254 } 255 } catch (Exception e) { 256 log.error("Unexpected error processing logs", e); 257 } 258 } 259 } 260 return new SearchResults(lineCount, (LogMessage[]) list.toArray(new LogMessage[list.size()]), capped); 261 } 262 263 264 public static final GBeanInfo GBEAN_INFO; 265 266 static { 267 GBeanInfoBuilder infoFactory = GBeanInfoBuilder.createStatic("Jetty Log Manager", JettyLogManagerImpl.class); 268 infoFactory.addReference("LogGBeans", JettyRequestLog.class); 269 infoFactory.addReference("ServerInfo", ServerInfo.class, "GBean"); 270 infoFactory.addInterface(JettyLogManager.class); 271 272 infoFactory.setConstructor(new String[]{"ServerInfo","LogGBeans"}); 273 GBEAN_INFO = infoFactory.getBeanInfo(); 274 } 275 276 public static GBeanInfo getGBeanInfo() { 277 return GBEAN_INFO; 278 } 279 280 /* 281 * Static inner class implementation of java.io.Filename. This will help us 282 * filter for only the files that we are interested in. 283 */ 284 static class PatternFilenameFilter implements FilenameFilter { 285 Pattern pattern; 286 //todo: put this pattern in a GBean parameter? 287 PatternFilenameFilter(String fileNamePattern) { 288 fileNamePattern = fileNamePattern.replaceAll("yyyy", "\\\\d{4}"); 289 fileNamePattern = fileNamePattern.replaceAll("yy", "\\\\d{2}"); 290 fileNamePattern = fileNamePattern.replaceAll("mm", "\\\\d{2}"); 291 fileNamePattern = fileNamePattern.replaceAll("dd", "\\\\d{2}"); 292 this.pattern = Pattern.compile(fileNamePattern); 293 } 294 295 public boolean accept(File file, String fileName) { 296 return pattern.matcher(fileName).matches(); 297 } 298 } 299 }