path: root/java/broker-plugins/management-jmx/src/main/java/org/apache/qpid/server/jmx/mbeans/LoggingManagementMBean.java

/*
 *  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);
        }
    }
}