qpid/java/broker/src/main/java/org/apache/qpid/server/configuration/plugins/ConfigurationPlugin.java - qpid - Git at Google

 /*
  * 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.configuration.plugins;

 import org.apache.commons.configuration.Configuration;
 import org.apache.commons.configuration.ConfigurationException;
 import org.apache.commons.configuration.ConversionException;
 import org.apache.log4j.Logger;

 import org.apache.qpid.server.configuration.ConfigurationManager;
 import org.apache.qpid.server.registry.ApplicationRegistry;
 import org.apache.qpid.server.registry.IApplicationRegistry;

 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Set;

 public abstract class ConfigurationPlugin
 {
     protected static final Logger _logger = Logger.getLogger(ConfigurationPlugin.class);

     private Map<String, ConfigurationPlugin>
             _pluginConfiguration = new HashMap<String, ConfigurationPlugin>();

     private Configuration _config;

     /**
      * The Elements that this Plugin can process.
      *
      * For a Queues plugin that would be a list containing:
      * <ul>
      * <li>queue - the queue entries
      * <li>the alerting values for defaults
      * <li>exchange - the default exchange
      * <li>durable - set the default durablity
      * </ul>
      */
     abstract public String[] getElementsProcessed();

     /** Performs configuration validation. */
     public void validateConfiguration() throws ConfigurationException
     {
         // Override in sub-classes
     }

     public Configuration getConfig()
     {
         return _config;
     }

     public <C extends ConfigurationPlugin> C getConfiguration(String plugin)
     {
         return (C) _pluginConfiguration.get(plugin);
     }

     /**
      * Sets the configuration for this plugin
      *
      * @param path
      * @param configuration the configuration for this plugin.
      */
     public void setConfiguration(String path, Configuration configuration) throws ConfigurationException
     {
         _config = configuration;

         // Extract a list of elements for processing
         Iterator<?> keys = configuration.getKeys();

         Set<String> elements = new HashSet<String>();
         while (keys.hasNext())
         {
             String key = (String) keys.next();

             int elementNameIndex = key.indexOf(".");

             String element = key.trim();
             if (elementNameIndex != -1)
             {
                 element = key.substring(0, elementNameIndex).trim();
             }

             // Trim any element properties
             elementNameIndex = element.indexOf("[");
             if (elementNameIndex > 0)
             {
                 element = element.substring(0, elementNameIndex).trim();
             }

             elements.add(element);
         }

         //Remove the items we already expect in the configuration
         for (String tag : getElementsProcessed())
         {

             // Work round the issue with Commons configuration.
             // With an XMLConfiguration the key will be [@property]
             // but with a CompositeConfiguration it will be @property].
             // Hide this issue from our users so when/if we change the
             // configuration they don't have to.
             int bracketIndex = tag.indexOf("[");
             if (bracketIndex != -1)
             {
                 tag = tag.substring(bracketIndex + 1, tag.length());
             }

             elements.remove(tag);
         }

         if (_logger.isInfoEnabled())
         {
             if (!elements.isEmpty())
             {
                 _logger.info("Elements to lookup:" + path);
                 for (String tag : elements)
                 {
                     _logger.info("Tag:'" + tag + "'");
                 }
             }
         }

         offerRemainingConfigurationToOtherPlugins(path, configuration, elements);

         validateConfiguration();
     }

     private void offerRemainingConfigurationToOtherPlugins(String path,
             Configuration configuration, Set<String> elements) throws ConfigurationException
     {
         final IApplicationRegistry appRegistry = safeGetApplicationRegistryInstance();

         if (appRegistry == null)
         {
             // We see this happen during shutdown due to asynchronous reconfig using IO threads.
             // Need to remove the responsibility for offering configuration to other class.
             _logger.info("Cannot offer remaining config to other plugins, can't find app registry");
             return;
         }

         final ConfigurationManager configurationManager = appRegistry.getConfigurationManager();
         // Process the elements in the configuration
         for (String element : elements)
         {
             Configuration handled = element.length() == 0 ? configuration : configuration.subset(element);

             String configurationElement = element;
             if (path.length() > 0)
             {
                 configurationElement = path + "." + configurationElement;
             }

             List<ConfigurationPlugin> handlers = configurationManager.getConfigurationPlugins(configurationElement, handled);

             if(_logger.isDebugEnabled())
             {
                 _logger.debug("For '" + element + "' found handlers (" + handlers.size() + "):" + handlers);
             }

             for (ConfigurationPlugin plugin : handlers)
             {
                 _pluginConfiguration.put(plugin.getClass().getName(), plugin);
             }
         }
     }

     private IApplicationRegistry safeGetApplicationRegistryInstance()
     {
         try
         {
             return ApplicationRegistry.getInstance();
         }
         catch (IllegalStateException ise)
         {
             return null;
         }
     }

     /** Helper method to print out list of keys in a {@link Configuration}. */
     public static final void showKeys(Configuration config)
     {
         if (config.isEmpty())
         {
             _logger.info("Configuration is empty");
         }
         else
         {
             Iterator<?> keys = config.getKeys();
             while (keys.hasNext())
             {
                 String key = (String) keys.next();
                 _logger.info("Configuration key: " + key);
             }
         }
     }

     protected boolean hasConfiguration()
     {
         return _config != null;
     }

     /// Getters

     protected double getDoubleValue(String property)
     {
         return getDoubleValue(property, 0.0);
     }

     protected double getDoubleValue(String property, double defaultValue)
     {
         return _config.getDouble(property, defaultValue);
     }

     protected long getLongValue(String property)
     {
         return getLongValue(property, 0);
     }

     protected long getLongValue(String property, long defaultValue)
     {
         return _config.getLong(property, defaultValue);
     }

     protected int getIntValue(String property)
     {
         return getIntValue(property, 0);
     }

     protected int getIntValue(String property, int defaultValue)
     {
         return _config.getInt(property, defaultValue);
     }

     protected String getStringValue(String property)
     {
         return getStringValue(property, null);
     }

     protected String getStringValue(String property, String defaultValue)
     {
         return _config.getString(property, defaultValue);
     }

     protected boolean getBooleanValue(String property)
     {
         return getBooleanValue(property, false);
     }

     protected boolean getBooleanValue(String property, boolean defaultValue)
     {
         return _config.getBoolean(property, defaultValue);
     }

     protected List getListValue(String property)
     {
         return getListValue(property, Collections.EMPTY_LIST);
     }

     protected List getListValue(String property, List defaultValue)
     {
         return _config.getList(property, defaultValue);
     }

     /// Validation Helpers

     protected boolean contains(String property)
     {
         return _config.getProperty(property) != null;
     }

     /**
      * Provide mechanism to validate Configuration contains a Postiive Long Value
      *
      * @param property
      *
      * @throws ConfigurationException
      */
     protected void validatePositiveLong(String property) throws ConfigurationException
     {
         try
         {
             if (!containsPositiveLong(property))
             {
                 throw new ConfigurationException(this.getClass().getSimpleName()
                                                  + ": '" + property +
                                                  "' must be a Positive Long value.");
             }
         }
         catch (Exception e)
         {
             Throwable last = e;

             // Find the first cause
             if (e instanceof ConversionException)
             {
                 Throwable t = e.getCause();
                 while (t != null)
                 {
                     last = t;
                     t = last.getCause();
                 }
             }

             throw new ConfigurationException(this.getClass().getSimpleName() +
                                              ": unable to configure invalid " +
                                              property + ":" +
                                              _config.getString(property),
                                              last);
         }
     }

     protected boolean containsLong(String property)
     {
         try
         {
             _config.getLong(property);
             return true;
         }
         catch (NoSuchElementException e)
         {
             return false;
         }
     }

     protected boolean containsPositiveLong(String property)
     {
         try
         {
             long value = _config.getLong(property);
             return value > 0;
         }
         catch (NoSuchElementException e)
         {
             return false;
         }

     }

     protected boolean containsInt(String property)
     {
         try
         {
             _config.getInt(property);
             return true;
         }
         catch (NoSuchElementException e)
         {
             return false;
         }
     }

     protected boolean containsBoolean(String property)
     {
         try
         {
             _config.getBoolean(property);
             return true;
         }
         catch (NoSuchElementException e)
         {
             return false;
         }
     }

     /**
      * Given another configuration merge the configuration into our own config
      *
      * The new values being merged in will take precedence over existing values.
      *
      * In the simplistic case this means something like:
      *
      * So if we have configuration set
      * name = 'fooo'
      *
      * And the new configuration contains a name then that will be reset.
      * name = 'new'
      *
      * However this plugin will simply contain other plugins so the merge will
      * be called until we end up at a base plugin that understand how to merge
      * items. i.e Alerting values. Where the provided configuration will take
      * precedence.
      *
      * @param configuration the config to merge in to our own.
      */
     public void addConfiguration(ConfigurationPlugin configuration)
     {
         // If given configuration is null then there is nothing to process.
         if (configuration == null)
         {
             return;
         }

         // Merge all the sub configuration items
         for (Map.Entry<String, ConfigurationPlugin> newPlugins : configuration._pluginConfiguration.entrySet())
         {
             String key = newPlugins.getKey();
             ConfigurationPlugin config = newPlugins.getValue();

             if (_pluginConfiguration.containsKey(key))
             {
                 //Merge the configuration if we already have this type of config
                 _pluginConfiguration.get(key).mergeConfiguration(config);
             }
             else
             {
                 //otherwise just add it to our config.
                 _pluginConfiguration.put(key, config);
             }
         }

         //Merge the configuration itself
         String key = configuration.getClass().getName();
         if (_pluginConfiguration.containsKey(key))
         {
             //Merge the configuration if we already have this type of config
             _pluginConfiguration.get(key).mergeConfiguration(configuration);
         }
         else
         {
             //If we are adding a configuration of our own type then merge
             if (configuration.getClass() == this.getClass())
             {
                 mergeConfiguration(configuration);
             }
             else
             {
                 // just store this in case someone else needs it.
                 _pluginConfiguration.put(key, configuration);
             }

         }

     }

     protected void mergeConfiguration(ConfigurationPlugin configuration)
     {
          _config = configuration.getConfig();
     }

     public String toString()
     {
         StringBuilder sb = new StringBuilder();

         sb.append("\n").append(getClass().getSimpleName());
         sb.append("=[ (").append(formatToString()).append(")");

         for(Map.Entry<String,ConfigurationPlugin> item : _pluginConfiguration.entrySet())
         {
             sb.append("\n").append(item.getValue());
         }

         sb.append("]\n");

         return sb.toString();
     }

     public String formatToString()
     {
         return super.toString();
     }

     protected void setConfig(Configuration config)
     {
         _config = config;
     }
 }
	/*
	* 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.configuration.plugins;

	import org.apache.commons.configuration.Configuration;
	import org.apache.commons.configuration.ConfigurationException;
	import org.apache.commons.configuration.ConversionException;
	import org.apache.log4j.Logger;

	import org.apache.qpid.server.configuration.ConfigurationManager;
	import org.apache.qpid.server.registry.ApplicationRegistry;
	import org.apache.qpid.server.registry.IApplicationRegistry;

	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.NoSuchElementException;
	import java.util.Set;

	public abstract class ConfigurationPlugin
	{
	protected static final Logger _logger = Logger.getLogger(ConfigurationPlugin.class);

	private Map<String, ConfigurationPlugin>
	_pluginConfiguration = new HashMap<String, ConfigurationPlugin>();

	private Configuration _config;

	/**
	* The Elements that this Plugin can process.
	*
	* For a Queues plugin that would be a list containing:
	* <ul>
	* <li>queue - the queue entries
	* <li>the alerting values for defaults
	* <li>exchange - the default exchange
	* <li>durable - set the default durablity
	* </ul>
	*/
	abstract public String[] getElementsProcessed();

	/** Performs configuration validation. */
	public void validateConfiguration() throws ConfigurationException
	{
	// Override in sub-classes
	}

	public Configuration getConfig()
	{
	return _config;
	}

	public <C extends ConfigurationPlugin> C getConfiguration(String plugin)
	{
	return (C) _pluginConfiguration.get(plugin);
	}

	/**
	* Sets the configuration for this plugin
	*
	* @param path
	* @param configuration the configuration for this plugin.
	*/
	public void setConfiguration(String path, Configuration configuration) throws ConfigurationException
	{
	_config = configuration;

	// Extract a list of elements for processing
	Iterator<?> keys = configuration.getKeys();

	Set<String> elements = new HashSet<String>();
	while (keys.hasNext())
	{
	String key = (String) keys.next();

	int elementNameIndex = key.indexOf(".");

	String element = key.trim();
	if (elementNameIndex != -1)
	{
	element = key.substring(0, elementNameIndex).trim();
	}

	// Trim any element properties
	elementNameIndex = element.indexOf("[");
	if (elementNameIndex > 0)
	{
	element = element.substring(0, elementNameIndex).trim();
	}

	elements.add(element);
	}

	//Remove the items we already expect in the configuration
	for (String tag : getElementsProcessed())
	{

	// Work round the issue with Commons configuration.
	// With an XMLConfiguration the key will be [@property]
	// but with a CompositeConfiguration it will be @property].
	// Hide this issue from our users so when/if we change the
	// configuration they don't have to.
	int bracketIndex = tag.indexOf("[");
	if (bracketIndex != -1)
	{
	tag = tag.substring(bracketIndex + 1, tag.length());
	}

	elements.remove(tag);
	}

	if (_logger.isInfoEnabled())
	{
	if (!elements.isEmpty())
	{
	_logger.info("Elements to lookup:" + path);
	for (String tag : elements)
	{
	_logger.info("Tag:'" + tag + "'");
	}
	}
	}

	offerRemainingConfigurationToOtherPlugins(path, configuration, elements);

	validateConfiguration();
	}

	private void offerRemainingConfigurationToOtherPlugins(String path,
	Configuration configuration, Set<String> elements) throws ConfigurationException
	{
	final IApplicationRegistry appRegistry = safeGetApplicationRegistryInstance();

	if (appRegistry == null)
	{
	// We see this happen during shutdown due to asynchronous reconfig using IO threads.
	// Need to remove the responsibility for offering configuration to other class.
	_logger.info("Cannot offer remaining config to other plugins, can't find app registry");
	return;
	}

	final ConfigurationManager configurationManager = appRegistry.getConfigurationManager();
	// Process the elements in the configuration
	for (String element : elements)
	{
	Configuration handled = element.length() == 0 ? configuration : configuration.subset(element);

	String configurationElement = element;
	if (path.length() > 0)
	{
	configurationElement = path + "." + configurationElement;
	}

	List<ConfigurationPlugin> handlers = configurationManager.getConfigurationPlugins(configurationElement, handled);

	if(_logger.isDebugEnabled())
	{
	_logger.debug("For '" + element + "' found handlers (" + handlers.size() + "):" + handlers);
	}

	for (ConfigurationPlugin plugin : handlers)
	{
	_pluginConfiguration.put(plugin.getClass().getName(), plugin);
	}
	}
	}

	private IApplicationRegistry safeGetApplicationRegistryInstance()
	{
	try
	{
	return ApplicationRegistry.getInstance();
	}
	catch (IllegalStateException ise)
	{
	return null;
	}
	}

	/** Helper method to print out list of keys in a {@link Configuration}. */
	public static final void showKeys(Configuration config)
	{
	if (config.isEmpty())
	{
	_logger.info("Configuration is empty");
	}
	else
	{
	Iterator<?> keys = config.getKeys();
	while (keys.hasNext())
	{
	String key = (String) keys.next();
	_logger.info("Configuration key: " + key);
	}
	}
	}

	protected boolean hasConfiguration()
	{
	return _config != null;
	}

	/// Getters

	protected double getDoubleValue(String property)
	{
	return getDoubleValue(property, 0.0);
	}

	protected double getDoubleValue(String property, double defaultValue)
	{
	return _config.getDouble(property, defaultValue);
	}

	protected long getLongValue(String property)
	{
	return getLongValue(property, 0);
	}

	protected long getLongValue(String property, long defaultValue)
	{
	return _config.getLong(property, defaultValue);
	}

	protected int getIntValue(String property)
	{
	return getIntValue(property, 0);
	}

	protected int getIntValue(String property, int defaultValue)
	{
	return _config.getInt(property, defaultValue);
	}

	protected String getStringValue(String property)
	{
	return getStringValue(property, null);
	}

	protected String getStringValue(String property, String defaultValue)
	{
	return _config.getString(property, defaultValue);
	}

	protected boolean getBooleanValue(String property)
	{
	return getBooleanValue(property, false);
	}

	protected boolean getBooleanValue(String property, boolean defaultValue)
	{
	return _config.getBoolean(property, defaultValue);
	}

	protected List getListValue(String property)
	{
	return getListValue(property, Collections.EMPTY_LIST);
	}

	protected List getListValue(String property, List defaultValue)
	{
	return _config.getList(property, defaultValue);
	}

	/// Validation Helpers

	protected boolean contains(String property)
	{
	return _config.getProperty(property) != null;
	}

	/**
	* Provide mechanism to validate Configuration contains a Postiive Long Value
	*
	* @param property
	*
	* @throws ConfigurationException
	*/
	protected void validatePositiveLong(String property) throws ConfigurationException
	{
	try
	{
	if (!containsPositiveLong(property))
	{
	throw new ConfigurationException(this.getClass().getSimpleName()
	+ ": '" + property +
	"' must be a Positive Long value.");
	}
	}
	catch (Exception e)
	{
	Throwable last = e;

	// Find the first cause
	if (e instanceof ConversionException)
	{
	Throwable t = e.getCause();
	while (t != null)
	{
	last = t;
	t = last.getCause();
	}
	}

	throw new ConfigurationException(this.getClass().getSimpleName() +
	": unable to configure invalid " +
	property + ":" +
	_config.getString(property),
	last);
	}
	}

	protected boolean containsLong(String property)
	{
	try
	{
	_config.getLong(property);
	return true;
	}
	catch (NoSuchElementException e)
	{
	return false;
	}
	}

	protected boolean containsPositiveLong(String property)
	{
	try
	{
	long value = _config.getLong(property);
	return value > 0;
	}
	catch (NoSuchElementException e)
	{
	return false;
	}

	}

	protected boolean containsInt(String property)
	{
	try
	{
	_config.getInt(property);
	return true;
	}
	catch (NoSuchElementException e)
	{
	return false;
	}
	}

	protected boolean containsBoolean(String property)
	{
	try
	{
	_config.getBoolean(property);
	return true;
	}
	catch (NoSuchElementException e)
	{
	return false;
	}
	}

	/**
	* Given another configuration merge the configuration into our own config
	*
	* The new values being merged in will take precedence over existing values.
	*
	* In the simplistic case this means something like:
	*
	* So if we have configuration set
	* name = 'fooo'
	*
	* And the new configuration contains a name then that will be reset.
	* name = 'new'
	*
	* However this plugin will simply contain other plugins so the merge will
	* be called until we end up at a base plugin that understand how to merge
	* items. i.e Alerting values. Where the provided configuration will take
	* precedence.
	*
	* @param configuration the config to merge in to our own.
	*/
	public void addConfiguration(ConfigurationPlugin configuration)
	{
	// If given configuration is null then there is nothing to process.
	if (configuration == null)
	{
	return;
	}

	// Merge all the sub configuration items
	for (Map.Entry<String, ConfigurationPlugin> newPlugins : configuration._pluginConfiguration.entrySet())
	{
	String key = newPlugins.getKey();
	ConfigurationPlugin config = newPlugins.getValue();

	if (_pluginConfiguration.containsKey(key))
	{
	//Merge the configuration if we already have this type of config
	_pluginConfiguration.get(key).mergeConfiguration(config);
	}
	else
	{
	//otherwise just add it to our config.
	_pluginConfiguration.put(key, config);
	}
	}

	//Merge the configuration itself
	String key = configuration.getClass().getName();
	if (_pluginConfiguration.containsKey(key))
	{
	//Merge the configuration if we already have this type of config
	_pluginConfiguration.get(key).mergeConfiguration(configuration);
	}
	else
	{
	//If we are adding a configuration of our own type then merge
	if (configuration.getClass() == this.getClass())
	{
	mergeConfiguration(configuration);
	}
	else
	{
	// just store this in case someone else needs it.
	_pluginConfiguration.put(key, configuration);
	}

	}

	}

	protected void mergeConfiguration(ConfigurationPlugin configuration)
	{
	_config = configuration.getConfig();
	}

	public String toString()
	{
	StringBuilder sb = new StringBuilder();

	sb.append("\n").append(getClass().getSimpleName());
	sb.append("=[ (").append(formatToString()).append(")");

	for(Map.Entry<String,ConfigurationPlugin> item : _pluginConfiguration.entrySet())
	{
	sb.append("\n").append(item.getValue());
	}

	sb.append("]\n");

	return sb.toString();
	}

	public String formatToString()
	{
	return super.toString();
	}

	protected void setConfig(Configuration config)
	{
	_config = config;
	}
	}