RC9/qpid/java/management/client/src/main/java/org/apache/qpid/management/configuration/Configuration.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.management.configuration;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
 import java.util.Map.Entry;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.SynchronousQueue;

 import org.apache.qpid.management.Messages;
 import org.apache.qpid.management.Names;
 import org.apache.qpid.management.domain.handler.base.IMessageHandler;
 import org.apache.qpid.management.domain.handler.impl.InvocationResult;
 import org.apache.qpid.management.domain.model.AccessMode;
 import org.apache.qpid.management.domain.model.type.Type;
 import org.apache.qpid.transport.DeliveryProperties;
 import org.apache.qpid.transport.Header;
 import org.apache.qpid.transport.MessageProperties;
 import org.apache.qpid.transport.ReplyTo;
 import org.apache.qpid.transport.util.Logger;

 /**
  * Qpid Management bridge configuration.
  * Basically iy is a singleton that is holding all the configurtion data loaded at startup.
  *
  * @author Andrea Gazzarini
  */
 public final class Configuration
 {
     private final static Logger LOGGER = Logger.get(Configuration.class);
     private static Configuration INSTANCE = new Configuration();

     Map<Integer, Type> _typeMappings = new HashMap<Integer,Type>();
     Map<Integer,AccessMode> _accessModes = new HashMap<Integer, AccessMode>();
     Map<Type,String> _validators = new HashMap<Type, String>();

     Map<UUID,BrokerConnectionData> _brokerConnectionInfos = new HashMap<UUID, BrokerConnectionData>();

     Map<Character, String> _managementQueueHandlers = new HashMap<Character, String>();
     Map<Character, String> _methodReplyQueueHandlers = new HashMap<Character, String>();

     private String _managementQueueName;
     private String _methodReplyQueueName;

     private Header _headerForCommandMessages;
     private DeliveryProperties _deliveryProperties = new DeliveryProperties();
     private MessageProperties _messageProperties = new MessageProperties();
     public BlockingQueue<InvocationResult> _resultExchangeChannel = new SynchronousQueue<InvocationResult>();

     // Private constructor.
     private Configuration()
     {
         defineQueueNames();
         createHeaderForCommandMessages();
     }

     /**
      * Returns the singleton instance.
      *
      * @return the singleton instance.
      */
     public static Configuration getInstance ()
     {
         return INSTANCE;
     }

     /**
      * Returns true if this configuration has at least one broker connection data.
      *
      * @return true if this configuration has at least one broker connection data.
      */
     public boolean hasOneOrMoreBrokersDefined()
     {
     	return !_brokerConnectionInfos.isEmpty();
     }

     /**
      * Returns the type associated to the given code.
      *
      * @param code the code used as search criteria.
      * @return the type associated to the given code.
      * @throws UnknownTypeCodeException when the given code is not associated to any type.
      */
     public Type getType(int code) throws UnknownTypeCodeException
     {
         Type result = _typeMappings.get(code);
         if (result == null)
         {
             throw new UnknownTypeCodeException(code);
         }
         return result;
     }

     /**
      * Returns the access mode associated to the given code.
      *
      * @param code the code used as search criteria.
      * @return the access mode associated to the given code.
      * @throws UnknownAccessCodeException when the given code is not associated to any access mode.
      */
     public AccessMode getAccessMode(int code) throws UnknownAccessCodeException
     {
         AccessMode result = _accessModes.get(code);
         if (result == null)
         {
             throw new UnknownAccessCodeException(code);
         }
         return result;
     }

     /**
      * Returns the validator class name associated to the given type.
      *
      * @param type the type.
      * @return the validator class name associated to the given type.
      */
     public String getValidatorClassName (Type type)
     {
         return _validators.get(type);
     }

     /**
      * Gets from this configuration the list of known broker (I mean, only their connection data).
      *
      * @return the list of known broker
      */
     public Set<Entry<UUID, BrokerConnectionData>> getConnectionInfos(){
         return _brokerConnectionInfos.entrySet();
     }

     /**
      * Gets from this configuration the connection data of the broker associated with the given id.
      *
      * @param brokerId the broker identifier.
      * @return the connection data of the broker associated with the given id.
      * @throws UnknownBrokerException when the given id is not associated with any broker.
      */
     public BrokerConnectionData getBrokerConnectionData (UUID brokerId) throws UnknownBrokerException
     {
         BrokerConnectionData connectionData = _brokerConnectionInfos.get(brokerId);
         if (connectionData == null)
         {
             throw new UnknownBrokerException(brokerId);
         }
         return _brokerConnectionInfos.get(brokerId);
     }

     /**
      * Returns the name of the management queue.
      *
      * @return the name of the management queue.
      */
     public String getManagementQueueName() {
         return _managementQueueName;
     }

     /**
      * Returns the name of the method-reply queue.
      *
      * @return the name of the method-reply queue.
      */
     public String getMethodReplyQueueName() {
         return _methodReplyQueueName;
     }

     /**
      * Returns a map containing all the configured management message handlers.
      * A management message handler it is a basically a processor for a management queue incoming message associated
      * with a specific opcode.
      *
      * @return a map containing all the configured management message handlers.
      */
     public Map<Character, IMessageHandler> getManagementQueueHandlers()
     {
         Map<Character, IMessageHandler> result = new HashMap<Character, IMessageHandler>();

         for (Entry<Character, String> entry : _managementQueueHandlers.entrySet())
         {
             Character opcode = entry.getKey();
             String className = entry.getValue();
             try
             {
                 result.put(opcode, (IMessageHandler)Class.forName(className).newInstance());
             } catch(Exception exception)
             {
                 LOGGER.error(exception,Messages.QMAN_100008_MANAGEMENT_MESSAGE_HANDLER_NOT_AVAILABLE,opcode);
             }
         }
         return result;
     }

     /**
      * Returns a map containing all the configured method-reply message handlers.
      * A management message handler it is a basically a processor for a method-reply queue incoming message associated
      * with a specific opcode.
      *
      * @return a map containing all the configured method-reply  message handlers.
      */
     public Map<Character, IMessageHandler> getMethodReplyQueueHandlers()
     {
         Map<Character, IMessageHandler> result = new HashMap<Character, IMessageHandler>();

         for (Entry<Character, String> entry : _methodReplyQueueHandlers.entrySet())
         {
             Character opcode = entry.getKey();
             String className = entry.getValue();
             try
             {
                 result.put(opcode, (IMessageHandler)Class.forName(className).newInstance());
             } catch(Exception exception)
             {
                 LOGGER.error(exception,Messages.QMAN_100009_METHOD_REPLY_MESSAGE_HANDLER_NOT_AVAILABLE,opcode);
             }
         }
         return result;
     }

     /**
      * Returns the message header used for sending command message on management queue.
      *
      * @return the message header used for sending command message on management queue.
      */
     public Header getCommandMessageHeader ()
     {
         return _headerForCommandMessages;
     }

     /**
      * Returns the command message properties.
      *
      * @return the command message properties.
      */
     public MessageProperties getCommandMessageProperties ()
     {
         return _messageProperties;
     }

     /**
      * Returns the command message delivery properties.
      *
      * @return the command message delivery properties.
      */
     public DeliveryProperties getCommandDeliveryProperties ()
     {
         return _deliveryProperties;
     }

     /**
      * Adds a new type mapping to this configuration.
      *
      * @param mapping the type mapping that will be added.
      */
     void addTypeMapping(TypeMapping mapping) {
         int code = mapping.getCode();
         Type type = mapping.getType();
         String validatorClassName = mapping.getValidatorClassName();
         _typeMappings.put(code, type);
         _validators.put(type, validatorClassName);

         LOGGER.info(Messages.QMAN_000005_TYPE_MAPPING_CONFIGURED, code,type,validatorClassName);
     }

     /**
      * Adds a new access mode mapping to this configuration.
      *
      * @param mapping the mapping that will be added.
      */
     void addAccessModeMapping(AccessModeMapping mapping){
         int code = mapping.getCode();
         AccessMode accessMode = mapping.getAccessMode();
         _accessModes.put(code, accessMode);

         LOGGER.info(Messages.QMAN_000006_ACCESS_MODE_MAPPING_CONFIGURED, code,accessMode);
     }

     /**
      * Adds a new management message handler to this configuration.
      * The incoming mapping object will contains an opcode and the class (as a string) of the message handler that will be used
      * for processing incoming messages with that opcode.
      *
      * @param mapping the message handler mapping.
      */
     void addManagementMessageHandlerMapping (MessageHandlerMapping mapping)
     {
         Character opcode = mapping.getOpcode();
         String handlerClass = mapping.getMessageHandlerClass();
         _managementQueueHandlers.put(opcode, handlerClass);

         LOGGER.info(Messages.QMAN_000007_MANAGEMENT_HANDLER_MAPPING_CONFIGURED, opcode,handlerClass);
     }

     /**
      * Adds a new method-reply message handler to this configuration.
      * The incoming mapping object will contains an opcode and the class (as a string) of the message handler that will be used
      * for processing incoming messages with that opcode.
      *
      * @param mapping the message handler mapping.
      */
     void addMethodReplyMessageHandlerMapping (MessageHandlerMapping mapping)
     {
         Character opcode = mapping.getOpcode();
         String handlerClass = mapping.getMessageHandlerClass();
         _methodReplyQueueHandlers.put(opcode, handlerClass);

         LOGGER.info(Messages.QMAN_000008_METHOD_REPLY_HANDLER_MAPPING_CONFIGURED, opcode,handlerClass);
     }

     /**
      * Adds to this configuration a new broker connection data.
      *
      * @param brokerId the broker identifier.
      * @param connectionData the connection data.
      * @throws BrokerAlreadyConnectedException when the broker is already connected.
      * @throws BrokerConnectionException when a connection cannot be estabilished.
      */
     void addBrokerConnectionData (UUID brokerId, BrokerConnectionData connectionData) throws BrokerAlreadyConnectedException, BrokerConnectionException
     {
     	if (_brokerConnectionInfos.containsValue(connectionData))
     	{
     		throw new BrokerAlreadyConnectedException(connectionData);
     	}

     	try
     	{
         	QpidDatasource.getInstance().addConnectionPool(brokerId, connectionData);
             _brokerConnectionInfos.put(brokerId,connectionData);

             LOGGER.info(Messages.QMAN_000009_BROKER_DATA_CONFIGURED,brokerId,connectionData);
     	} catch(Exception exception)
     	{
     		throw new BrokerConnectionException(exception);
     	}

     }

     /**
      * Header for command messages is created once because it only contains static values.
      */
     private void createHeaderForCommandMessages ()
     {
         ReplyTo replyTo=new ReplyTo();
         replyTo.setRoutingKey(_methodReplyQueueName);
         _messageProperties.setReplyTo(replyTo);
         _deliveryProperties.setRoutingKey(Names.AGENT_ROUTING_KEY);
         _headerForCommandMessages = new Header(_deliveryProperties, _messageProperties);
     }

     /**
      * Creates the name of the queues used by this service.
      * This is done because if a broker should be managed by one or more management client, then each of them
      * must have its own channels to communicate with.
      */
     private void defineQueueNames()
     {
         UUID uuid = UUID.randomUUID();
         _managementQueueName = Names.MANAGEMENT_QUEUE_PREFIX+uuid;
         _methodReplyQueueName = Names.METHOD_REPLY_QUEUE_PREFIX+uuid;

         LOGGER.debug(Messages.QMAN_200004_MANAGEMENT_QUEUE_NAME,_managementQueueName);
         LOGGER.debug(Messages.QMAN_200005_METHOD_REPLY_QUEUE_NAME,_methodReplyQueueName);
     }
 }
	/*
	*
	* 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.management.configuration;

	import java.util.HashMap;
	import java.util.Map;
	import java.util.Set;
	import java.util.UUID;
	import java.util.Map.Entry;
	import java.util.concurrent.BlockingQueue;
	import java.util.concurrent.SynchronousQueue;

	import org.apache.qpid.management.Messages;
	import org.apache.qpid.management.Names;
	import org.apache.qpid.management.domain.handler.base.IMessageHandler;
	import org.apache.qpid.management.domain.handler.impl.InvocationResult;
	import org.apache.qpid.management.domain.model.AccessMode;
	import org.apache.qpid.management.domain.model.type.Type;
	import org.apache.qpid.transport.DeliveryProperties;
	import org.apache.qpid.transport.Header;
	import org.apache.qpid.transport.MessageProperties;
	import org.apache.qpid.transport.ReplyTo;
	import org.apache.qpid.transport.util.Logger;

	/**
	* Qpid Management bridge configuration.
	* Basically iy is a singleton that is holding all the configurtion data loaded at startup.
	*
	* @author Andrea Gazzarini
	*/
	public final class Configuration
	{
	private final static Logger LOGGER = Logger.get(Configuration.class);
	private static Configuration INSTANCE = new Configuration();

	Map<Integer, Type> _typeMappings = new HashMap<Integer,Type>();
	Map<Integer,AccessMode> _accessModes = new HashMap<Integer, AccessMode>();
	Map<Type,String> _validators = new HashMap<Type, String>();

	Map<UUID,BrokerConnectionData> _brokerConnectionInfos = new HashMap<UUID, BrokerConnectionData>();

	Map<Character, String> _managementQueueHandlers = new HashMap<Character, String>();
	Map<Character, String> _methodReplyQueueHandlers = new HashMap<Character, String>();

	private String _managementQueueName;
	private String _methodReplyQueueName;

	private Header _headerForCommandMessages;
	private DeliveryProperties _deliveryProperties = new DeliveryProperties();
	private MessageProperties _messageProperties = new MessageProperties();
	public BlockingQueue<InvocationResult> _resultExchangeChannel = new SynchronousQueue<InvocationResult>();

	// Private constructor.
	private Configuration()
	{
	defineQueueNames();
	createHeaderForCommandMessages();
	}

	/**
	* Returns the singleton instance.
	*
	* @return the singleton instance.
	*/
	public static Configuration getInstance ()
	{
	return INSTANCE;
	}

	/**
	* Returns true if this configuration has at least one broker connection data.
	*
	* @return true if this configuration has at least one broker connection data.
	*/
	public boolean hasOneOrMoreBrokersDefined()
	{
	return !_brokerConnectionInfos.isEmpty();
	}

	/**
	* Returns the type associated to the given code.
	*
	* @param code the code used as search criteria.
	* @return the type associated to the given code.
	* @throws UnknownTypeCodeException when the given code is not associated to any type.
	*/
	public Type getType(int code) throws UnknownTypeCodeException
	{
	Type result = _typeMappings.get(code);
	if (result == null)
	{
	throw new UnknownTypeCodeException(code);
	}
	return result;
	}

	/**
	* Returns the access mode associated to the given code.
	*
	* @param code the code used as search criteria.
	* @return the access mode associated to the given code.
	* @throws UnknownAccessCodeException when the given code is not associated to any access mode.
	*/
	public AccessMode getAccessMode(int code) throws UnknownAccessCodeException
	{
	AccessMode result = _accessModes.get(code);
	if (result == null)
	{
	throw new UnknownAccessCodeException(code);
	}
	return result;
	}

	/**
	* Returns the validator class name associated to the given type.
	*
	* @param type the type.
	* @return the validator class name associated to the given type.
	*/
	public String getValidatorClassName (Type type)
	{
	return _validators.get(type);
	}

	/**
	* Gets from this configuration the list of known broker (I mean, only their connection data).
	*
	* @return the list of known broker
	*/
	public Set<Entry<UUID, BrokerConnectionData>> getConnectionInfos(){
	return _brokerConnectionInfos.entrySet();
	}

	/**
	* Gets from this configuration the connection data of the broker associated with the given id.
	*
	* @param brokerId the broker identifier.
	* @return the connection data of the broker associated with the given id.
	* @throws UnknownBrokerException when the given id is not associated with any broker.
	*/
	public BrokerConnectionData getBrokerConnectionData (UUID brokerId) throws UnknownBrokerException
	{
	BrokerConnectionData connectionData = _brokerConnectionInfos.get(brokerId);
	if (connectionData == null)
	{
	throw new UnknownBrokerException(brokerId);
	}
	return _brokerConnectionInfos.get(brokerId);
	}

	/**
	* Returns the name of the management queue.
	*
	* @return the name of the management queue.
	*/
	public String getManagementQueueName() {
	return _managementQueueName;
	}

	/**
	* Returns the name of the method-reply queue.
	*
	* @return the name of the method-reply queue.
	*/
	public String getMethodReplyQueueName() {
	return _methodReplyQueueName;
	}

	/**
	* Returns a map containing all the configured management message handlers.
	* A management message handler it is a basically a processor for a management queue incoming message associated
	* with a specific opcode.
	*
	* @return a map containing all the configured management message handlers.
	*/
	public Map<Character, IMessageHandler> getManagementQueueHandlers()
	{
	Map<Character, IMessageHandler> result = new HashMap<Character, IMessageHandler>();

	for (Entry<Character, String> entry : _managementQueueHandlers.entrySet())
	{
	Character opcode = entry.getKey();
	String className = entry.getValue();
	try
	{
	result.put(opcode, (IMessageHandler)Class.forName(className).newInstance());
	} catch(Exception exception)
	{
	LOGGER.error(exception,Messages.QMAN_100008_MANAGEMENT_MESSAGE_HANDLER_NOT_AVAILABLE,opcode);
	}
	}
	return result;
	}

	/**
	* Returns a map containing all the configured method-reply message handlers.
	* A management message handler it is a basically a processor for a method-reply queue incoming message associated
	* with a specific opcode.
	*
	* @return a map containing all the configured method-reply message handlers.
	*/
	public Map<Character, IMessageHandler> getMethodReplyQueueHandlers()
	{
	Map<Character, IMessageHandler> result = new HashMap<Character, IMessageHandler>();

	for (Entry<Character, String> entry : _methodReplyQueueHandlers.entrySet())
	{
	Character opcode = entry.getKey();
	String className = entry.getValue();
	try
	{
	result.put(opcode, (IMessageHandler)Class.forName(className).newInstance());
	} catch(Exception exception)
	{
	LOGGER.error(exception,Messages.QMAN_100009_METHOD_REPLY_MESSAGE_HANDLER_NOT_AVAILABLE,opcode);
	}
	}
	return result;
	}

	/**
	* Returns the message header used for sending command message on management queue.
	*
	* @return the message header used for sending command message on management queue.
	*/
	public Header getCommandMessageHeader ()
	{
	return _headerForCommandMessages;
	}

	/**
	* Returns the command message properties.
	*
	* @return the command message properties.
	*/
	public MessageProperties getCommandMessageProperties ()
	{
	return _messageProperties;
	}

	/**
	* Returns the command message delivery properties.
	*
	* @return the command message delivery properties.
	*/
	public DeliveryProperties getCommandDeliveryProperties ()
	{
	return _deliveryProperties;
	}

	/**
	* Adds a new type mapping to this configuration.
	*
	* @param mapping the type mapping that will be added.
	*/
	void addTypeMapping(TypeMapping mapping) {
	int code = mapping.getCode();
	Type type = mapping.getType();
	String validatorClassName = mapping.getValidatorClassName();
	_typeMappings.put(code, type);
	_validators.put(type, validatorClassName);

	LOGGER.info(Messages.QMAN_000005_TYPE_MAPPING_CONFIGURED, code,type,validatorClassName);
	}

	/**
	* Adds a new access mode mapping to this configuration.
	*
	* @param mapping the mapping that will be added.
	*/
	void addAccessModeMapping(AccessModeMapping mapping){
	int code = mapping.getCode();
	AccessMode accessMode = mapping.getAccessMode();
	_accessModes.put(code, accessMode);

	LOGGER.info(Messages.QMAN_000006_ACCESS_MODE_MAPPING_CONFIGURED, code,accessMode);
	}

	/**
	* Adds a new management message handler to this configuration.
	* The incoming mapping object will contains an opcode and the class (as a string) of the message handler that will be used
	* for processing incoming messages with that opcode.
	*
	* @param mapping the message handler mapping.
	*/
	void addManagementMessageHandlerMapping (MessageHandlerMapping mapping)
	{
	Character opcode = mapping.getOpcode();
	String handlerClass = mapping.getMessageHandlerClass();
	_managementQueueHandlers.put(opcode, handlerClass);

	LOGGER.info(Messages.QMAN_000007_MANAGEMENT_HANDLER_MAPPING_CONFIGURED, opcode,handlerClass);
	}

	/**
	* Adds a new method-reply message handler to this configuration.
	* The incoming mapping object will contains an opcode and the class (as a string) of the message handler that will be used
	* for processing incoming messages with that opcode.
	*
	* @param mapping the message handler mapping.
	*/
	void addMethodReplyMessageHandlerMapping (MessageHandlerMapping mapping)
	{
	Character opcode = mapping.getOpcode();
	String handlerClass = mapping.getMessageHandlerClass();
	_methodReplyQueueHandlers.put(opcode, handlerClass);

	LOGGER.info(Messages.QMAN_000008_METHOD_REPLY_HANDLER_MAPPING_CONFIGURED, opcode,handlerClass);
	}

	/**
	* Adds to this configuration a new broker connection data.
	*
	* @param brokerId the broker identifier.
	* @param connectionData the connection data.
	* @throws BrokerAlreadyConnectedException when the broker is already connected.
	* @throws BrokerConnectionException when a connection cannot be estabilished.
	*/
	void addBrokerConnectionData (UUID brokerId, BrokerConnectionData connectionData) throws BrokerAlreadyConnectedException, BrokerConnectionException
	{
	if (_brokerConnectionInfos.containsValue(connectionData))
	{
	throw new BrokerAlreadyConnectedException(connectionData);
	}

	try
	{
	QpidDatasource.getInstance().addConnectionPool(brokerId, connectionData);
	_brokerConnectionInfos.put(brokerId,connectionData);

	LOGGER.info(Messages.QMAN_000009_BROKER_DATA_CONFIGURED,brokerId,connectionData);
	} catch(Exception exception)
	{
	throw new BrokerConnectionException(exception);
	}

	}

	/**
	* Header for command messages is created once because it only contains static values.
	*/
	private void createHeaderForCommandMessages ()
	{
	ReplyTo replyTo=new ReplyTo();
	replyTo.setRoutingKey(_methodReplyQueueName);
	_messageProperties.setReplyTo(replyTo);
	_deliveryProperties.setRoutingKey(Names.AGENT_ROUTING_KEY);
	_headerForCommandMessages = new Header(_deliveryProperties, _messageProperties);
	}

	/**
	* Creates the name of the queues used by this service.
	* This is done because if a broker should be managed by one or more management client, then each of them
	* must have its own channels to communicate with.
	*/
	private void defineQueueNames()
	{
	UUID uuid = UUID.randomUUID();
	_managementQueueName = Names.MANAGEMENT_QUEUE_PREFIX+uuid;
	_methodReplyQueueName = Names.METHOD_REPLY_QUEUE_PREFIX+uuid;

	LOGGER.debug(Messages.QMAN_200004_MANAGEMENT_QUEUE_NAME,_managementQueueName);
	LOGGER.debug(Messages.QMAN_200005_METHOD_REPLY_QUEUE_NAME,_methodReplyQueueName);
	}
	}