1 files changed, 324 insertions, 0 deletions
diff --git a/java/broker-plugins/management-jmx/src/main/java/org/apache/qpid/server/jmx/mbeans/LoggingManagementMBean.java b/java/broker-plugins/management-jmx/src/main/java/org/apache/qpid/server/jmx/mbeans/LoggingManagementMBean.java
new file mode 100644
index 0000000000..0dac8ebe37
--- /dev/null
+++ b/java/broker-plugins/management-jmx/src/main/java/org/apache/qpid/server/jmx/mbeans/LoggingManagementMBean.java
@@ -0,0 +1,324 @@
+/*
+ *  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.jmx.mbeans;
+
+import org.apache.log4j.Logger;
+import org.apache.qpid.management.common.mbeans.LoggingManagement;
+import org.apache.qpid.management.common.mbeans.annotations.MBeanDescription;
+import org.apache.qpid.server.jmx.AMQManagedObject;
+import org.apache.qpid.server.jmx.ManagedObject;
+import org.apache.qpid.server.jmx.ManagedObjectRegistry;
+import org.apache.qpid.server.logging.log4j.LoggingFacade;
+import org.apache.qpid.server.logging.log4j.LoggingFacadeException;
+
+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 java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+
+/** MBean class for LoggingManagement. It implements all the management features exposed for managing logging. */
+@MBeanDescription("Logging Management Interface")
+public class LoggingManagementMBean extends AMQManagedObject implements LoggingManagement
+{
+    public static final String INHERITED_PSUEDO_LOG_LEVEL = "INHERITED";
+    private static final Logger LOGGER = Logger.getLogger(LoggingManagementMBean.class);
+    private static final TabularType LOGGER_LEVEL_TABULAR_TYE;
+    private static final CompositeType LOGGER_LEVEL_COMPOSITE_TYPE;
+
+    private final LoggingFacade _configurator;
+
+    static
+    {
+        try
+        {
+            OpenType[] loggerLevelItemTypes = new OpenType[]{SimpleType.STRING, SimpleType.STRING};
+
+            LOGGER_LEVEL_COMPOSITE_TYPE = 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);
+
+            LOGGER_LEVEL_TABULAR_TYE = new TabularType("LoggerLevel", "List of loggers with levels",
+                                                       LOGGER_LEVEL_COMPOSITE_TYPE,
+                                                       TABULAR_UNIQUE_INDEX.toArray(new String[TABULAR_UNIQUE_INDEX.size()]));
+        }
+        catch (OpenDataException e)
+        {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+    
+    public LoggingManagementMBean(LoggingFacade configurator, ManagedObjectRegistry registry) throws JMException
+    {
+        super(LoggingManagement.class, LoggingManagement.TYPE, registry);
+        register();
+        _configurator = configurator;
+    }
+
+    @Override
+    public String getObjectInstanceName()
+    {
+        return LoggingManagement.TYPE;
+    }
+
+    @Override
+    public ManagedObject getParentObject()
+    {
+        return null;
+    }
+
+    @Override
+    public Integer getLog4jLogWatchInterval()
+    {
+        return _configurator.getLog4jLogWatchInterval();
+    }
+    
+    @Override
+    public String[] getAvailableLoggerLevels()
+    {
+        List<String> levels = _configurator.getAvailableLoggerLevels();
+        List<String> mbeanLevels = new ArrayList<String>(levels);
+        mbeanLevels.add(INHERITED_PSUEDO_LOG_LEVEL);
+        
+        return mbeanLevels.toArray(new String[mbeanLevels.size()]);
+    }
+
+    @Override
+    public TabularData viewEffectiveRuntimeLoggerLevels()
+    {
+        Map<String, String> levels = _configurator.retrieveRuntimeLoggersLevels();
+        return createTabularDataFromLevelsMap(levels);
+    }
+
+    @Override
+    public String getRuntimeRootLoggerLevel()
+    {
+        return _configurator.retrieveRuntimeRootLoggerLevel();
+    }
+
+    @Override
+    public boolean setRuntimeRootLoggerLevel(String level)
+    {
+        try
+        {
+            validateLevelNotAllowingInherited(level);
+        }
+        catch (IllegalArgumentException iae)
+        {
+            LOGGER.warn(level + " is not a known level");
+            return false;
+        }
+
+        _configurator.setRuntimeRootLoggerLevel(level);
+        return true;
+    }
+
+    @Override
+    public boolean setRuntimeLoggerLevel(String logger, String level)
+    {
+        String validatedLevel;
+        try
+        {
+            validatedLevel = getValidateLevelAllowingInherited(level);
+        }
+        catch (IllegalArgumentException iae)
+        {
+            LOGGER.warn(level + " is not a known level");
+            return false;
+        }
+
+        try
+        {
+            _configurator.setRuntimeLoggerLevel(logger, validatedLevel);
+        }
+        catch (LoggingFacadeException e)
+        {
+            LOGGER.error("Cannot set runtime logging level", e);
+           return false;
+        }
+        return true;
+    }
+
+    @Override
+    public TabularData viewConfigFileLoggerLevels()
+    {
+        Map<String,String> levels;
+        try
+        {
+            levels = _configurator.retrieveConfigFileLoggersLevels();
+        }
+        catch (LoggingFacadeException e)
+        {
+            LOGGER.error("Cannot determine logging levels", e);
+           return null;
+        }
+
+        return createTabularDataFromLevelsMap(levels);
+    }
+
+    @Override
+    public String getConfigFileRootLoggerLevel()throws IOException
+    {
+        try
+        {
+            return _configurator.retrieveConfigFileRootLoggerLevel().toUpperCase();
+        }
+        catch (LoggingFacadeException e)
+        {
+            LOGGER.warn("The log4j configuration get config request was aborted: ", e);
+            throw new IOException("The log4j configuration get config request was aborted: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public boolean setConfigFileLoggerLevel(String logger, String level)
+    {
+        String validatedLevel;
+        try
+        {
+            validatedLevel = getValidateLevelAllowingInherited(level);
+        }
+        catch (IllegalArgumentException iae)
+        {
+            LOGGER.warn(level + " is not a known level");
+            return false;
+        }
+
+        try
+        {
+            _configurator.setConfigFileLoggerLevel(logger, validatedLevel);
+        }
+        catch (LoggingFacadeException e)
+        {
+            LOGGER.warn("The log4j configuration set config request was aborted: ", e);
+            return false;
+        }
+        return true;
+    }
+    
+    @Override
+    public boolean setConfigFileRootLoggerLevel(String level)
+    {
+        try
+        {
+            validateLevelNotAllowingInherited(level);
+        }
+        catch (IllegalArgumentException iae)
+        {
+            LOGGER.warn(level + " is not a known level");
+            return false;
+        }
+
+        try
+        {
+            _configurator.setConfigFileRootLoggerLevel(level);
+            return true;
+        }
+        catch (LoggingFacadeException e)
+        {
+            LOGGER.warn("The log4j configuration set config request was aborted: ", e);
+            return false;
+        }
+    }
+
+    @Override
+    public void reloadConfigFile() throws IOException
+    {
+        try
+        {
+
+            _configurator.reload();
+        }
+        catch (LoggingFacadeException e)
+        {
+            LOGGER.warn("The log4j configuration reload request was aborted: ", e);
+            throw new IOException("The log4j configuration reload request was aborted: " + e.getMessage());
+        }
+    }
+
+    private String getValidateLevelAllowingInherited(String level)
+    {
+        if(level == null
+            || "null".equalsIgnoreCase(level)
+            || INHERITED_PSUEDO_LOG_LEVEL.equalsIgnoreCase(level))
+        {
+            //the string "null" or "inherited" signals to inherit from a parent logger,
+            //using a null Level reference for the logger.
+            return null;
+        }
+
+        validateLevelNotAllowingInherited(level);
+        return level;
+    }
+
+    private void validateLevelNotAllowingInherited(String level)
+    {
+        final List<String> availableLoggerLevels = _configurator.getAvailableLoggerLevels();
+        if (!availableLoggerLevels.contains(level)
+             && !availableLoggerLevels.contains(String.valueOf(level).toUpperCase()))
+        {
+            throw new IllegalArgumentException(level + " not known");
+        }
+    }
+
+    private TabularData createTabularDataFromLevelsMap(Map<String, String> levels)
+    {
+        TabularData loggerLevelList = new TabularDataSupport(LOGGER_LEVEL_TABULAR_TYE);
+        for (Map.Entry<String,String> entry : levels.entrySet())
+        {
+            String loggerName = entry.getKey();
+            String level = entry.getValue();
+
+            CompositeData loggerData = createRow(loggerName, level);
+            loggerLevelList.put(loggerData);
+        }
+        return loggerLevelList;
+    }
+
+
+    private CompositeData createRow(String loggerName, String level)
+    {
+        Object[] itemData = {loggerName, level.toUpperCase()};
+        try
+        {
+            CompositeData loggerData = new CompositeDataSupport(LOGGER_LEVEL_COMPOSITE_TYPE,
+                    COMPOSITE_ITEM_NAMES.toArray(new String[COMPOSITE_ITEM_NAMES.size()]), itemData);
+            return loggerData;
+        }
+        catch (OpenDataException ode)
+        {
+            // Should not happen
+            throw new RuntimeException(ode);
+        }
+    }
+}