001: package com.sun.portal.log.common;
002:
003: import java.io.File;
004: import java.io.FilenameFilter;
005: import java.io.IOException;
006: import java.util.HashSet;
007: import java.util.Hashtable;
008: import java.util.logging.FileHandler;
009: import java.util.logging.Formatter;
010: import java.util.logging.Handler;
011: import java.util.logging.Level;
012: import java.util.logging.LogRecord;
013: import java.util.logging.Logger;
014: import java.util.regex.Pattern;
015:
016: /**
017: *
018: */
019: public class LoggersList {
020:
021: public static final String LOGGERS_LIST_FILE_PREFIX = ".loggersList.";
022: //if you change this, modify getListLoggerFile(..) also
023: public static final String LOGGERS_LIST_FILE_SUFFIX = "."
024: + PortalLogManager.SRA_COMPONENT_TYPE_PATTERN
025: + PortalLogManager.INSTANCE_ID_PATTERN;
026:
027: private static Hashtable fileToInstanceTable = new Hashtable();
028: private String fileName;
029: private static Logger listLogger;
030: private String LOGGER_NAME = "com.sun.portal.loggers.list";
031: private int LIMIT = 5000000;
032: private int COUNT = 1;
033: private static HashSet loggersSet = new HashSet();
034: public static final String COMPONENT_PORTAL_INSTANCE = "portal";
035: public static final String COMPONENT_GW_INSTANCE = "gateway";
036: public static final String COMPONENT_NLP_INSTANCE = "nlproxy";
037: public static final String COMPONENT_RWP_INSTANCE = "rwproxy";
038: public static final String COMPONENT_SEARCH_INSTANCE = "search";
039: public static final String COMPONENT_PAS_INSTANCE = "pas";
040: public static final String COMPONENT_PSCONSOLE_INSTANCE = "psconsole";
041:
042: // Value of the tag %sraComponentType set by SRA classes
043: private static final String SRA_COMPONENT_TYPE_GATEWAY = "gateway";
044: private static final String SRA_COMPONENT_TYPE_NLPROXY = "nlproxy";
045: private static final String SRA_COMPONENT_TYPE_RWPROXY = "rwproxy";
046:
047: private LoggersList(String fileName, boolean special) {
048: File configFile = new File(fileName);
049: String folderName = configFile.getParent();
050: this .fileName = folderName
051: + "/"
052: + LOGGERS_LIST_FILE_PREFIX
053: + configFile.getName()
054: + (special ? ""
055: : replaceToken(LOGGERS_LIST_FILE_SUFFIX));
056: Logger tmpLogger = createLogger(this .fileName);
057: configureLogger(this .fileName, tmpLogger, special);
058: if (!special) {
059: listLogger = tmpLogger;
060: } else {
061: addSearchLoggers(tmpLogger);
062: }
063: }
064:
065: private void addSearchLoggers(Logger tmpLogger) {
066: tmpLogger.log(Level.CONFIG,
067: PortalLogManager.DEBUG_ROOT_LOGGER_SEARCH);
068: tmpLogger.log(Level.CONFIG,
069: PortalLogManager.DEBUG_ROOT_LOGGER_SEARCH + ".rdm");
070: tmpLogger.log(Level.CONFIG,
071: PortalLogManager.DEBUG_ROOT_LOGGER_SEARCH
072: + ".rdmserver");
073: tmpLogger.log(Level.CONFIG,
074: PortalLogManager.DEBUG_ROOT_LOGGER_SEARCH + ".rdmgr");
075: }
076:
077: public static String getListLoggerFile(String componentName,
078: String logConfigFileName, String instance) {
079: StringBuffer loggerListFileName = new StringBuffer();
080: File configFile = new File(logConfigFileName);
081: String tempFileName = configFile.getParent();
082: loggerListFileName.append(tempFileName);
083: loggerListFileName.append("/");
084: loggerListFileName.append(LOGGERS_LIST_FILE_PREFIX);
085: loggerListFileName.append(configFile.getName());
086:
087: if (LoggersList.COMPONENT_PORTAL_INSTANCE.equals(componentName)) {
088: //portal => .loggerlist.PSLogConfig.properties.<instance>
089: loggerListFileName.append(".");
090: loggerListFileName.append(instance);
091: } else if (LoggersList.COMPONENT_GW_INSTANCE
092: .equals(componentName)) {
093: //gateway => .loggerlist.platform.conf.<instance>.gateway
094: loggerListFileName.append(".");
095: loggerListFileName.append(SRA_COMPONENT_TYPE_GATEWAY);
096: } else if (LoggersList.COMPONENT_NLP_INSTANCE
097: .equals(componentName)) {
098: //nlproxy => .loggerlist.platform.conf.<instance>.nlproxy
099: loggerListFileName.append(".");
100: loggerListFileName.append(SRA_COMPONENT_TYPE_NLPROXY);
101: } else if (LoggersList.COMPONENT_RWP_INSTANCE
102: .equals(componentName)) {
103: //rwproxy => .loggerlist.platform.conf.<instance>.rwproxy
104: loggerListFileName.append(".");
105: loggerListFileName.append(SRA_COMPONENT_TYPE_RWPROXY);
106: } else if (LoggersList.COMPONENT_SEARCH_INSTANCE
107: .equals(componentName)) {
108: //search => .loggerlist.SearchLogConfig.properties
109: // do nothing
110: } else if (LoggersList.COMPONENT_PAS_INSTANCE
111: .equals(componentName)
112: || LoggersList.COMPONENT_PSCONSOLE_INSTANCE
113: .equals(componentName)) {
114: // pas or console => .loggerlist.AdminLogConfig.properties.
115: loggerListFileName.append(".");
116: } else {
117: // do nothing
118: }
119: return loggerListFileName.toString();
120: }
121:
122: private static String replaceToken(String srcString) {
123: String dest = srcString;
124: if (dest != null) {
125: if (dest.indexOf(PortalLogManager.INSTANCE_ID_PATTERN) >= 0) {
126: String instanceID = System.getProperty(
127: PortalLogManager.INSTANCE_ID_PROPERTY, "");
128: dest = Pattern.compile(
129: PortalLogManager.INSTANCE_ID_PATTERN).matcher(
130: dest).replaceAll(instanceID);
131: }
132: if (dest
133: .indexOf(PortalLogManager.SRA_COMPONENT_TYPE_PATTERN) >= 0) {
134: String sracomponentID = System.getProperty(
135: PortalLogManager.SRA_COMPONENT_TYPE_PROPERTY,
136: "");
137: dest = Pattern.compile(
138: PortalLogManager.SRA_COMPONENT_TYPE_PATTERN)
139: .matcher(dest).replaceAll(sracomponentID);
140: }
141: }
142: return dest;
143: }
144:
145: private void configureLogger(String filename, Logger tmpLogger,
146: boolean special) {
147: tmpLogger.setUseParentHandlers(false);
148: tmpLogger.setLevel(Level.CONFIG);
149: boolean ourHandler = false;
150: try {
151: Handler[] handlers = tmpLogger.getHandlers();
152: if (handlers != null) {
153: StringBuffer buffer = new StringBuffer();
154: for (int i = 0; i < handlers.length; i++) {
155: buffer.append(handlers[i].getClass().getName());
156: Formatter formatter = handlers[i].getFormatter();
157: String className = formatter.getClass().getName();
158: String tempClassName = ListLoggerFormatter.class
159: .getName();
160: // If the Formatter Name is different it means We didn't add the Handler
161: // so remove it and add our handler
162: // If the Formatter Name is same, we already added it, so don't remove
163: // it.
164: if (!className.equals(tempClassName)) {
165: try {
166: handlers[i].close();
167: } catch (Exception e) {
168: //drop by
169: }
170: tmpLogger.removeHandler(handlers[i]);
171: } else {
172: ourHandler = true;
173: }
174: }
175: if (!ourHandler)
176: addHandler(filename, tmpLogger);
177: // There should not be more than one FileHandler, if there is
178: // its an error
179: if (handlers.length > 1) {
180: PortalLogDebug.info("More than one Handler:"
181: + buffer);
182: }
183: } else {
184: addHandler(filename, tmpLogger);
185: }
186: } catch (IOException e) {
187: PortalLogDebug.error("Could not create loggers list. "
188: + e.getMessage());
189: }
190: }
191:
192: private void addHandler(String filename, Logger tmpLogger)
193: throws IOException {
194: boolean append = false;
195: FileHandler fileHandler = new FileHandler(this .fileName, LIMIT,
196: COUNT, append);
197: fileHandler.setFormatter(new ListLoggerFormatter());
198: fileHandler.setLevel(Level.CONFIG);
199: tmpLogger.addHandler(fileHandler);
200: }
201:
202: private Logger createLogger(String filename) {
203: String loggerName = LOGGER_NAME + filename.replaceAll("/", ".");
204: return Logger.getLogger(loggerName);
205: }
206:
207: public static LoggersList init(String fullPathConfigFileName,
208: boolean special) {
209: if (fileToInstanceTable.containsKey(fullPathConfigFileName)) {
210: return (LoggersList) fileToInstanceTable
211: .get(fullPathConfigFileName);
212: }
213: LoggersList instance = new LoggersList(fullPathConfigFileName,
214: special);
215: fileToInstanceTable.put(fullPathConfigFileName, instance);
216: return instance;
217: }
218:
219: public static LoggersList initSearch(String fullPathConfigFileName,
220: boolean special) {
221: if (fileToInstanceTable.containsKey(fullPathConfigFileName)) {
222: return (LoggersList) fileToInstanceTable
223: .get(fullPathConfigFileName);
224: }
225: LoggersList instance = new LoggersList(fullPathConfigFileName,
226: special);
227: fileToInstanceTable.put(fullPathConfigFileName, instance);
228: return instance;
229: }
230:
231: public static void add(String loggerName) {
232: if (!loggersSet.contains(loggerName)
233: && !loggerName
234: .startsWith(PortalLogManager.DEBUG_ROOT_LOGGER_SEARCH)) {
235: loggersSet.add(loggerName);
236: if (listLogger != null)
237: listLogger.log(Level.CONFIG, loggerName);
238: }
239: }
240:
241: protected static void delete(String fullPathConfigFile,
242: String sraComponentType) {
243: File configFile = new File(fullPathConfigFile);
244: String folderName = configFile.getParent();
245: System.setProperty(
246: PortalLogManager.SRA_COMPONENT_TYPE_PROPERTY,
247: sraComponentType);
248: String dest = replaceToken(LOGGERS_LIST_FILE_SUFFIX);
249: String fileName = folderName + "/" + LOGGERS_LIST_FILE_PREFIX
250: + configFile.getName() + dest;
251: File dir = new File(folderName);
252: File[] fileList = dir.listFiles(new ListLoggerFilenameFilter(
253: fileName));
254: for (int i = 0; i < fileList.length; i++) {
255: fileList[i].delete();
256: }
257: }
258:
259: public static void main(String[] args) {
260: LoggersList
261: .init(
262: "/var/opt/SUNWportal/portals/portal1/config/PSLogConfig.properties",
263: false);
264: LoggersList.add("debug.com.sun.portal.log");
265: LoggersList.add("debug.com.sun.portal.log");
266: LoggersList.add("debug.com.sun.portal.log.common");
267: }
268: }
269:
270: class ListLoggerFormatter extends Formatter {
271: public String getHead(Handler h) {
272: return "# DO NOT DELETE THIS FILE.\n# "
273: + "This lists the loggers of a portal component and is used by the logging CLI "
274: + "and Console applications.\n";
275: }
276:
277: public String format(LogRecord record) {
278: return record.getMessage() + "\n";
279: }
280: }
281:
282: class ListLoggerFilenameFilter implements FilenameFilter {
283: private String loggersListName;
284:
285: ListLoggerFilenameFilter(String loggersListName) {
286: int index = loggersListName.lastIndexOf("/");
287: if (index != -1)
288: this .loggersListName = loggersListName.substring(index + 1);
289: else
290: this .loggersListName = loggersListName;
291: }
292:
293: public boolean accept(File dir, String name) {
294: return (name.startsWith(loggersListName));
295: }
296:
297: }
|