| /* |
| * 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.qpid.server.logging.management; |
| |
| import org.apache.log4j.Level; |
| import org.apache.log4j.LogManager; |
| import org.apache.log4j.Logger; |
| import org.apache.log4j.xml.Log4jEntityResolver; |
| import org.apache.log4j.xml.QpidLog4JConfigurator; |
| import org.apache.log4j.xml.QpidLog4JConfigurator.IllegalLoggerLevelException; |
| import org.apache.log4j.xml.QpidLog4JConfigurator.QpidLog4JSaxErrorHandler; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.SAXException; |
| |
| import org.apache.qpid.management.common.mbeans.LoggingManagement; |
| import org.apache.qpid.management.common.mbeans.annotations.MBeanDescription; |
| import org.apache.qpid.server.management.AMQManagedObject; |
| |
| import javax.management.JMException; |
| import javax.management.openmbean.CompositeData; |
| import javax.management.openmbean.CompositeDataSupport; |
| import javax.management.openmbean.CompositeType; |
| import javax.management.openmbean.OpenDataException; |
| import javax.management.openmbean.OpenType; |
| import javax.management.openmbean.SimpleType; |
| import javax.management.openmbean.TabularData; |
| import javax.management.openmbean.TabularDataSupport; |
| import javax.management.openmbean.TabularType; |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.ParserConfigurationException; |
| import javax.xml.transform.OutputKeys; |
| import javax.xml.transform.Transformer; |
| import javax.xml.transform.TransformerException; |
| import javax.xml.transform.TransformerFactory; |
| import javax.xml.transform.dom.DOMSource; |
| import javax.xml.transform.stream.StreamResult; |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Random; |
| |
| import static org.apache.log4j.xml.QpidLog4JConfigurator.LOCK; |
| |
| |
| /** MBean class for BrokerLoggingManagerMBean. It implements all the management features exposed for managing logging. */ |
| @MBeanDescription("Logging Management Interface") |
| public class LoggingManagementMBean extends AMQManagedObject implements LoggingManagement |
| { |
| |
| private static final Logger _logger = Logger.getLogger(LoggingManagementMBean.class); |
| private String _log4jConfigFileName; |
| private int _log4jLogWatchInterval; |
| private static final String INHERITED = "INHERITED"; |
| private static final String[] LEVELS = new String[]{Level.ALL.toString(), Level.TRACE.toString(), |
| Level.DEBUG.toString(), Level.INFO.toString(), |
| Level.WARN.toString(), Level.ERROR.toString(), |
| Level.FATAL.toString(),Level.OFF.toString(), |
| INHERITED}; |
| private static TabularType _loggerLevelTabularType; |
| private static CompositeType _loggerLevelCompositeType; |
| |
| static |
| { |
| try |
| { |
| OpenType[] loggerLevelItemTypes = new OpenType[]{SimpleType.STRING, SimpleType.STRING}; |
| |
| _loggerLevelCompositeType = new CompositeType("LoggerLevelList", "Logger Level Data", |
| COMPOSITE_ITEM_NAMES.toArray(new String[COMPOSITE_ITEM_NAMES.size()]), |
| COMPOSITE_ITEM_DESCRIPTIONS.toArray(new String[COMPOSITE_ITEM_DESCRIPTIONS.size()]), |
| loggerLevelItemTypes); |
| |
| _loggerLevelTabularType = new TabularType("LoggerLevel", "List of loggers with levels", |
| _loggerLevelCompositeType, |
| TABULAR_UNIQUE_INDEX.toArray(new String[TABULAR_UNIQUE_INDEX.size()])); |
| } |
| catch (OpenDataException e) |
| { |
| _logger.error("Tabular data setup for viewing logger levels was incorrect."); |
| _loggerLevelTabularType = null; |
| } |
| } |
| |
| public LoggingManagementMBean(String log4jConfigFileName, int log4jLogWatchInterval) throws JMException |
| { |
| super(LoggingManagement.class, LoggingManagement.TYPE); |
| _log4jConfigFileName = log4jConfigFileName; |
| _log4jLogWatchInterval = log4jLogWatchInterval; |
| } |
| |
| public String getObjectInstanceName() |
| { |
| return LoggingManagement.TYPE; |
| } |
| |
| public Integer getLog4jLogWatchInterval() |
| { |
| return _log4jLogWatchInterval; |
| } |
| |
| public String[] getAvailableLoggerLevels() |
| { |
| return LEVELS; |
| } |
| @SuppressWarnings("unchecked") |
| public synchronized boolean setRuntimeLoggerLevel(String logger, String level) |
| { |
| //check specified level is valid |
| Level newLevel; |
| try |
| { |
| newLevel = getLevel(level); |
| } |
| catch (Exception e) |
| { |
| return false; |
| } |
| |
| //check specified logger exists |
| Enumeration loggers = LogManager.getCurrentLoggers(); |
| Boolean loggerExists = false; |
| |
| while(loggers.hasMoreElements()) |
| { |
| Logger log = (Logger) loggers.nextElement(); |
| if (log.getName().equals(logger)) |
| { |
| loggerExists = true; |
| break; |
| } |
| } |
| |
| if(!loggerExists) |
| { |
| return false; |
| } |
| |
| //set the logger to the new level |
| _logger.info("Setting level to " + level + " for logger: " + logger); |
| |
| Logger log = Logger.getLogger(logger); |
| log.setLevel(newLevel); |
| |
| return true; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public synchronized TabularData viewEffectiveRuntimeLoggerLevels() |
| { |
| if (_loggerLevelTabularType == null) |
| { |
| _logger.warn("TabluarData type not set up correctly"); |
| return null; |
| } |
| |
| _logger.info("Getting levels for currently active log4j loggers"); |
| |
| Enumeration loggers = LogManager.getCurrentLoggers(); |
| |
| TabularData loggerLevelList = new TabularDataSupport(_loggerLevelTabularType); |
| |
| Logger logger; |
| String loggerName; |
| String level; |
| |
| try |
| { |
| while(loggers.hasMoreElements()){ |
| logger = (Logger) loggers.nextElement(); |
| |
| loggerName = logger.getName(); |
| level = logger.getEffectiveLevel().toString(); |
| |
| Object[] itemData = {loggerName, level}; |
| CompositeData loggerData = new CompositeDataSupport(_loggerLevelCompositeType, |
| COMPOSITE_ITEM_NAMES.toArray(new String[COMPOSITE_ITEM_NAMES.size()]), itemData); |
| loggerLevelList.put(loggerData); |
| } |
| } |
| catch (OpenDataException e) |
| { |
| _logger.warn("Unable to create logger level list due to :" + e); |
| return null; |
| } |
| |
| return loggerLevelList; |
| |
| } |
| |
| public synchronized String getRuntimeRootLoggerLevel() |
| { |
| Logger rootLogger = Logger.getRootLogger(); |
| |
| return rootLogger.getLevel().toString(); |
| } |
| |
| public synchronized boolean setRuntimeRootLoggerLevel(String level) |
| { |
| Level newLevel; |
| try |
| { |
| newLevel = getLevel(level); |
| } |
| catch (Exception e) |
| { |
| return false; |
| } |
| |
| if(newLevel == null) |
| { |
| //A null Level reference implies inheritance. Setting the runtime RootLogger |
| //to null is catastrophic (and prevented by Log4J at startup and runtime anyway). |
| return false; |
| } |
| |
| _logger.info("Setting RootLogger level to " + level); |
| |
| Logger log = Logger.getRootLogger(); |
| log.setLevel(newLevel); |
| |
| return true; |
| } |
| |
| //method to convert from a string to a log4j Level, throws exception if the given value is invalid |
| private Level getLevel(String level) throws Exception |
| { |
| if("null".equalsIgnoreCase(level) || INHERITED.equalsIgnoreCase(level)) |
| { |
| //the string "null" or "inherited" signals to inherit from a parent logger, |
| //using a null Level reference for the logger. |
| return null; |
| } |
| |
| Level newLevel = Level.toLevel(level); |
| |
| //above Level.toLevel call returns a DEBUG Level if the request fails. Check the result. |
| if (newLevel.equals(Level.DEBUG) && !(level.equalsIgnoreCase("debug"))) |
| { |
| //received DEBUG but we did not ask for it, the Level request failed. |
| throw new Exception("Invalid level name"); |
| } |
| |
| return newLevel; |
| } |
| |
| //method to parse the XML configuration file, validating it in the process, and returning a DOM Document of the content. |
| private static synchronized Document parseConfigFile(String fileName) throws IOException |
| { |
| try |
| { |
| LOCK.lock(); |
| |
| //check file was specified, exists, and is readable |
| if(fileName == null) |
| { |
| _logger.warn("Provided log4j XML configuration filename is null"); |
| throw new IOException("Provided log4j XML configuration filename is null"); |
| } |
| |
| File configFile = new File(fileName); |
| |
| if (!configFile.exists()) |
| { |
| _logger.warn("The log4j XML configuration file could not be found: " + fileName); |
| throw new IOException("The log4j XML configuration file could not be found"); |
| } |
| else if (!configFile.canRead()) |
| { |
| _logger.warn("The log4j XML configuration file is not readable: " + fileName); |
| throw new IOException("The log4j XML configuration file is not readable"); |
| } |
| |
| //parse it |
| DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance(); |
| DocumentBuilder docBuilder; |
| Document doc; |
| |
| ErrorHandler errHandler = new QpidLog4JSaxErrorHandler(); |
| try |
| { |
| docFactory.setValidating(true); |
| docBuilder = docFactory.newDocumentBuilder(); |
| docBuilder.setErrorHandler(errHandler); |
| docBuilder.setEntityResolver(new Log4jEntityResolver()); |
| doc = docBuilder.parse(fileName); |
| } |
| catch (ParserConfigurationException e) |
| { |
| _logger.warn("Unable to parse the log4j XML file due to possible configuration error: " + e); |
| //recommended that MBeans should use java.* and javax.* exceptions only |
| throw new IOException("Unable to parse the log4j XML file due to possible configuration error: " + e.getMessage()); |
| } |
| catch (SAXException e) |
| { |
| _logger.warn("The specified log4j XML file is invalid: " + e); |
| //recommended that MBeans should use standard java.* and javax.* exceptions only |
| throw new IOException("The specified log4j XML file is invalid: " + e.getMessage()); |
| } |
| catch (IOException e) |
| { |
| _logger.warn("Unable to parse the specified log4j XML file" + e); |
| throw new IOException("Unable to parse the specified log4j XML file: " + e.getMessage()); |
| } |
| |
| return doc; |
| } |
| finally |
| { |
| LOCK.unlock(); |
| } |
| } |
| |
| |
| private static synchronized boolean writeUpdatedConfigFile(String log4jConfigFileName, Document doc) throws IOException |
| { |
| try |
| { |
| LOCK.lock(); |
| |
| File log4jConfigFile = new File(log4jConfigFileName); |
| |
| if (!log4jConfigFile.canWrite()) |
| { |
| _logger.warn("Specified log4j XML configuration file is not writable: " + log4jConfigFile); |
| throw new IOException("Specified log4j XML configuration file is not writable"); |
| } |
| |
| Transformer transformer = null; |
| try |
| { |
| transformer = TransformerFactory.newInstance().newTransformer(); |
| } |
| catch (Exception e) |
| { |
| _logger.warn("Could not create an XML transformer: " +e); |
| return false; |
| } |
| |
| transformer.setOutputProperty(OutputKeys.INDENT, "yes"); |
| transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "log4j.dtd"); |
| DOMSource source = new DOMSource(doc); |
| |
| File tmp; |
| Random r = new Random(); |
| do |
| { |
| tmp = new File(log4jConfigFile.getPath() + r.nextInt() + ".tmp"); |
| } |
| while(tmp.exists()); |
| |
| tmp.deleteOnExit(); |
| |
| try |
| { |
| StreamResult result = new StreamResult(tmp); |
| transformer.transform(source, result); |
| } |
| catch (TransformerException e) |
| { |
| _logger.warn("Could not transform the XML into new file: " +e); |
| throw new IOException("Could not transform the XML into new file: " +e); |
| } |
| |
| // Swap temp file in to replace existing configuration file. |
| File old = new File(log4jConfigFile.getAbsoluteFile() + ".old"); |
| if (old.exists()) |
| { |
| old.delete(); |
| } |
| |
| if(!log4jConfigFile.renameTo(old)) |
| { |
| //unable to rename the existing file to the backup name |
| _logger.error("Could not backup the existing log4j XML file"); |
| throw new IOException("Could not backup the existing log4j XML file"); |
| } |
| |
| if(!tmp.renameTo(log4jConfigFile)) |
| { |
| //failed to rename the new file to the required filename |
| |
| if(!old.renameTo(log4jConfigFile)) |
| { |
| //unable to return the backup to required filename |
| _logger.error("Could not rename the new log4j configuration file into place, and unable to restore original file"); |
| throw new IOException("Could not rename the new log4j configuration file into place, and unable to restore original file"); |
| } |
| |
| _logger.error("Could not rename the new log4j configuration file into place"); |
| throw new IOException("Could not rename the new log4j configuration file into place"); |
| } |
| |
| return true; |
| } |
| finally |
| { |
| LOCK.unlock(); |
| } |
| } |
| |
| |
| /* The log4j XML configuration file DTD defines three possible element |
| * combinations for specifying optional logger+level settings. |
| * Must account for the following: |
| * |
| * <category name="x"> <priority value="y"/> </category> OR |
| * <category name="x"> <level value="y"/> </category> OR |
| * <logger name="x"> <level value="y"/> </logger> |
| * |
| * Noting also that the level/priority child element is optional too, |
| * and not the only possible child element. |
| */ |
| |
| public static synchronized Map<String,String> retrieveConfigFileLoggersLevels(String fileName) throws IOException |
| { |
| try |
| { |
| LOCK.lock(); |
| |
| Document doc = parseConfigFile(fileName); |
| |
| HashMap<String,String> loggerLevelList = new HashMap<String,String>(); |
| |
| //retrieve the 'category' element nodes |
| NodeList categoryElements = doc.getElementsByTagName("category"); |
| |
| String categoryName; |
| String priority = null; |
| |
| for (int i = 0; i < categoryElements.getLength(); i++) |
| { |
| Element categoryElement = (Element) categoryElements.item(i); |
| categoryName = categoryElement.getAttribute("name"); |
| |
| //retrieve the category's mandatory 'priority' or 'level' element's value. |
| //It may not be the only child node, so request by tag name. |
| NodeList priorityElements = categoryElement.getElementsByTagName("priority"); |
| NodeList levelElements = categoryElement.getElementsByTagName("level"); |
| |
| if (priorityElements.getLength() != 0) |
| { |
| Element priorityElement = (Element) priorityElements.item(0); |
| priority = priorityElement.getAttribute("value"); |
| } |
| else if (levelElements.getLength() != 0) |
| { |
| Element levelElement = (Element) levelElements.item(0); |
| priority = levelElement.getAttribute("value"); |
| } |
| else |
| { |
| //there is no exiting priority or level to view, move onto next category/logger |
| continue; |
| } |
| |
| loggerLevelList.put(categoryName, priority); |
| } |
| |
| //retrieve the 'logger' element nodes |
| NodeList loggerElements = doc.getElementsByTagName("logger"); |
| |
| String loggerName; |
| String level; |
| |
| for (int i = 0; i < loggerElements.getLength(); i++) |
| { |
| Element loggerElement = (Element) loggerElements.item(i); |
| loggerName = loggerElement.getAttribute("name"); |
| |
| //retrieve the logger's mandatory 'level' element's value |
| //It may not be the only child node, so request by tag name. |
| NodeList levelElements = loggerElement.getElementsByTagName("level"); |
| |
| Element levelElement = (Element) levelElements.item(0); |
| level = levelElement.getAttribute("value"); |
| |
| loggerLevelList.put(loggerName, level); |
| } |
| |
| return loggerLevelList; |
| } |
| finally |
| { |
| LOCK.unlock(); |
| } |
| } |
| |
| public synchronized TabularData viewConfigFileLoggerLevels() throws IOException |
| { |
| try |
| { |
| LOCK.lock(); |
| |
| if (_loggerLevelTabularType == null) |
| { |
| _logger.warn("TabluarData type not set up correctly"); |
| return null; |
| } |
| |
| _logger.info("Getting logger levels from log4j configuration file"); |
| |
| TabularData loggerLevelList = new TabularDataSupport(_loggerLevelTabularType); |
| |
| Map<String,String> levels = retrieveConfigFileLoggersLevels(_log4jConfigFileName); |
| |
| for (Map.Entry<String,String> entry : levels.entrySet()) |
| { |
| String loggerName = entry.getKey(); |
| String level = entry.getValue(); |
| |
| try |
| { |
| Object[] itemData = {loggerName, level.toUpperCase()}; |
| CompositeData loggerData = new CompositeDataSupport(_loggerLevelCompositeType, |
| COMPOSITE_ITEM_NAMES.toArray(new String[COMPOSITE_ITEM_NAMES.size()]), itemData); |
| loggerLevelList.put(loggerData); |
| } |
| catch (OpenDataException e) |
| { |
| _logger.warn("Unable to create logger level list due to :" + e); |
| return null; |
| } |
| } |
| |
| return loggerLevelList; |
| } |
| finally |
| { |
| LOCK.unlock(); |
| } |
| } |
| |
| public synchronized boolean setConfigFileLoggerLevel(String logger, String level) throws IOException |
| { |
| try |
| { |
| LOCK.lock(); |
| |
| //check that the specified level is a valid log4j Level |
| try |
| { |
| getLevel(level); |
| } |
| catch (Exception e) |
| { |
| //it isnt a valid level |
| return false; |
| } |
| |
| _logger.info("Setting level to " + level + " for logger '" + logger |
| + "' in log4j xml configuration file: " + _log4jConfigFileName); |
| |
| Document doc = parseConfigFile(_log4jConfigFileName); |
| |
| //retrieve the 'category' and 'logger' element nodes |
| NodeList categoryElements = doc.getElementsByTagName("category"); |
| NodeList loggerElements = doc.getElementsByTagName("logger"); |
| |
| //collect them into a single elements list |
| List<Element> logElements = new ArrayList<Element>(); |
| |
| for (int i = 0; i < categoryElements.getLength(); i++) |
| { |
| logElements.add((Element) categoryElements.item(i)); |
| } |
| for (int i = 0; i < loggerElements.getLength(); i++) |
| { |
| logElements.add((Element) loggerElements.item(i)); |
| } |
| |
| //try to locate the specified logger/category in the elements retrieved |
| Element logElement = null; |
| for (Element e : logElements) |
| { |
| if (e.getAttribute("name").equals(logger)) |
| { |
| logElement = e; |
| break; |
| } |
| } |
| |
| if (logElement == null) |
| { |
| //no loggers/categories with given name found, does not exist to update |
| _logger.warn("Specified logger does not exist in the configuration file: " +logger); |
| return false; |
| } |
| |
| //retrieve the optional 'priority' or 'level' sub-element value. |
| //It may not be the only child node, so request by tag name. |
| NodeList priorityElements = logElement.getElementsByTagName("priority"); |
| NodeList levelElements = logElement.getElementsByTagName("level"); |
| |
| Element levelElement = null; |
| if (priorityElements.getLength() != 0) |
| { |
| levelElement = (Element) priorityElements.item(0); |
| } |
| else if (levelElements.getLength() != 0) |
| { |
| levelElement = (Element) levelElements.item(0); |
| } |
| else |
| { |
| //there is no exiting priority or level element to update |
| return false; |
| } |
| |
| //update the element with the new level/priority |
| levelElement.setAttribute("value", level.toLowerCase()); |
| |
| //output the new file |
| return writeUpdatedConfigFile(_log4jConfigFileName, doc); |
| } |
| finally |
| { |
| LOCK.unlock(); |
| } |
| } |
| |
| |
| /* The log4j XML configuration file DTD defines 2 possible element |
| * combinations for specifying the optional root logger level settings |
| * Must account for the following: |
| * |
| * <root> <priority value="y"/> </root> OR |
| * <root> <level value="y"/> </root> |
| * |
| * Noting also that the level/priority child element is optional too, |
| * and not the only possible child element. |
| */ |
| |
| public static synchronized String retrieveConfigFileRootLoggerLevel(String fileName) throws IOException |
| { |
| try |
| { |
| LOCK.lock(); |
| |
| Document doc = parseConfigFile(fileName); |
| |
| //retrieve the optional 'root' element node |
| NodeList rootElements = doc.getElementsByTagName("root"); |
| |
| if (rootElements.getLength() == 0) |
| { |
| //there is no root logger definition |
| return "N/A"; |
| } |
| |
| Element rootElement = (Element) rootElements.item(0); |
| |
| //retrieve the optional 'priority' or 'level' element value. |
| //It may not be the only child node, so request by tag name. |
| NodeList priorityElements = rootElement.getElementsByTagName("priority"); |
| NodeList levelElements = rootElement.getElementsByTagName("level"); |
| String priority = null; |
| |
| if (priorityElements.getLength() != 0) |
| { |
| Element priorityElement = (Element) priorityElements.item(0); |
| priority = priorityElement.getAttribute("value"); |
| } |
| else if(levelElements.getLength() != 0) |
| { |
| Element levelElement = (Element) levelElements.item(0); |
| priority = levelElement.getAttribute("value"); |
| } |
| |
| if(priority != null) |
| { |
| return priority; |
| } |
| else |
| { |
| return "N/A"; |
| } |
| } |
| finally |
| { |
| LOCK.unlock(); |
| } |
| } |
| |
| public synchronized String getConfigFileRootLoggerLevel() throws IOException |
| { |
| return retrieveConfigFileRootLoggerLevel(_log4jConfigFileName).toUpperCase(); |
| } |
| |
| public synchronized boolean setConfigFileRootLoggerLevel(String level) throws IOException |
| { |
| try |
| { |
| LOCK.lock(); |
| |
| //check that the specified level is a valid log4j Level |
| try |
| { |
| Level newLevel = getLevel(level); |
| if(newLevel == null) |
| { |
| //A null Level reference implies inheritance. Setting the config file RootLogger |
| //to "null" or "inherited" just ensures it defaults to DEBUG at startup as Log4J |
| //prevents this catastrophic situation at startup and runtime anyway. |
| return false; |
| } |
| } |
| catch (Exception e) |
| { |
| //it isnt a valid level |
| return false; |
| } |
| |
| _logger.info("Setting level to " + level + " for the Root logger in " + |
| "log4j xml configuration file: " + _log4jConfigFileName); |
| |
| Document doc = parseConfigFile(_log4jConfigFileName); |
| |
| //retrieve the optional 'root' element node |
| NodeList rootElements = doc.getElementsByTagName("root"); |
| |
| if (rootElements.getLength() == 0) |
| { |
| return false; |
| } |
| |
| Element rootElement = (Element) rootElements.item(0); |
| |
| //retrieve the optional 'priority' or 'level' sub-element value. |
| //It may not be the only child node, so request by tag name. |
| NodeList priorityElements = rootElement.getElementsByTagName("priority"); |
| NodeList levelElements = rootElement.getElementsByTagName("level"); |
| |
| Element levelElement = null; |
| if (priorityElements.getLength() != 0) |
| { |
| levelElement = (Element) priorityElements.item(0); |
| } |
| else if (levelElements.getLength() != 0) |
| { |
| levelElement = (Element) levelElements.item(0); |
| } |
| else |
| { |
| //there is no exiting priority/level to update |
| return false; |
| } |
| |
| //update the element with the new level/priority |
| levelElement.setAttribute("value", level); |
| |
| //output the new file |
| return writeUpdatedConfigFile(_log4jConfigFileName, doc); |
| } |
| finally |
| { |
| LOCK.unlock(); |
| } |
| } |
| |
| public synchronized void reloadConfigFile() throws IOException |
| { |
| try |
| { |
| LOCK.lock(); |
| |
| QpidLog4JConfigurator.configure(_log4jConfigFileName); |
| _logger.info("Applied log4j configuration from: " + _log4jConfigFileName); |
| } |
| catch (IllegalLoggerLevelException e) |
| { |
| _logger.warn("The log4j configuration reload request was aborted: " + e); |
| //recommended that MBeans should use standard java.* and javax.* exceptions only |
| throw new IOException("The log4j configuration reload request was aborted: " + e.getMessage()); |
| } |
| catch (ParserConfigurationException e) |
| { |
| _logger.warn("The log4j configuration reload request was aborted: " + e); |
| throw new IOException("The log4j configuration reload request was aborted: " + e.getMessage()); |
| } |
| catch (SAXException e) |
| { |
| _logger.warn("The log4j configuration reload request was aborted: " + e); |
| //recommended that MBeans should use standard java.* and javax.* exceptions only |
| throw new IOException("The log4j configuration reload request was aborted: " + e.getMessage()); |
| } |
| catch (IOException e) |
| { |
| _logger.warn("The log4j configuration reload request was aborted: " + e); |
| throw new IOException("The log4j configuration reload request was aborted: " + e.getMessage()); |
| } |
| finally |
| { |
| LOCK.unlock(); |
| } |
| } |
| } |
