src/nms-api/NMSConnectionFactory.cs - activemq-nms-api - 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.
  */

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using System.Xml;

 using Apache.NMS.Util;

 namespace Apache.NMS
 {
 	/// <summary>
 	/// Provider implementation mapping class.
 	/// </summary>
 	public class ProviderFactoryInfo
 	{
 		public string assemblyFileName;
 		public string factoryClassName;

 		public ProviderFactoryInfo(string aFileName, string fClassName)
 		{
 			assemblyFileName = aFileName;
 			factoryClassName = fClassName;
 		}
 	}

 	/// <summary>
 	/// Implementation of a factory for <see cref="IConnection" /> instances.
 	/// </summary>
 	public class NMSConnectionFactory : IConnectionFactory
 	{
 		protected readonly IConnectionFactory factory;
 		protected static readonly Dictionary<string, ProviderFactoryInfo> schemaProviderFactoryMap;

 		/// <summary>
 		/// Static class constructor
 		/// </summary>
 		static NMSConnectionFactory()
 		{
 			schemaProviderFactoryMap = new Dictionary<string, ProviderFactoryInfo>();
             schemaProviderFactoryMap["activemq"] = new ProviderFactoryInfo("Apache.NMS.ActiveMQ", "Apache.NMS.ActiveMQ.ConnectionFactory");
             schemaProviderFactoryMap["activemqnettx"] = new ProviderFactoryInfo("Apache.NMS.ActiveMQ", "Apache.NMS.ActiveMQ.NetTxConnectionFactory");
 			schemaProviderFactoryMap["tcp"] = new ProviderFactoryInfo("Apache.NMS.ActiveMQ", "Apache.NMS.ActiveMQ.ConnectionFactory");
 			schemaProviderFactoryMap["ems"] = new ProviderFactoryInfo("Apache.NMS.EMS", "Apache.NMS.EMS.ConnectionFactory");
             schemaProviderFactoryMap["mqtt"] = new ProviderFactoryInfo("Apache.NMS.MQTT", "Apache.NMS.MQTT.ConnectionFactory");
             schemaProviderFactoryMap["msmq"] = new ProviderFactoryInfo("Apache.NMS.MSMQ", "Apache.NMS.MSMQ.ConnectionFactory");
 			schemaProviderFactoryMap["stomp"] = new ProviderFactoryInfo("Apache.NMS.Stomp", "Apache.NMS.Stomp.ConnectionFactory");
 			schemaProviderFactoryMap["xms"] = new ProviderFactoryInfo("Apache.NMS.XMS", "Apache.NMS.XMS.ConnectionFactory");
 			schemaProviderFactoryMap["zmq"] = new ProviderFactoryInfo("Apache.NMS.ZMQ", "Apache.NMS.ZMQ.ConnectionFactory");
 			schemaProviderFactoryMap["amqp"] = new ProviderFactoryInfo("Apache.NMS.AMQP", "Apache.NMS.AMQP.ConnectionFactory");
 		}

 		/// <summary>
 		/// The ConnectionFactory object must define a constructor that takes as a minimum a Uri object.
 		/// Any additional parameters are optional, but will typically include a Client ID string.
 		/// </summary>
 		/// <param name="providerURI">The URI for the ActiveMQ provider.</param>
 		/// <param name="constructorParams">Optional parameters to use when creating the ConnectionFactory.</param>
 		public NMSConnectionFactory(string providerURI, params object[] constructorParams)
 			: this(URISupport.CreateCompatibleUri(providerURI), constructorParams)
 		{
 		}

 		/// <summary>
 		/// The ConnectionFactory object must define a constructor that takes as a minimum a Uri object.
 		/// Any additional parameters are optional, but will typically include a Client ID string.
 		/// </summary>
 		/// <param name="uriProvider">The URI for the ActiveMQ provider.</param>
 		/// <param name="constructorParams">Optional parameters to use when creating the ConnectionFactory.</param>
 		public NMSConnectionFactory(Uri uriProvider, params object[] constructorParams)
 		{
 			this.factory = CreateConnectionFactory(uriProvider, constructorParams);
 		}

 		/// <summary>
 		/// Create a connection factory that can create connections for the given scheme in the URI.
 		/// </summary>
 		/// <param name="uriProvider">The URI for the ActiveMQ provider.</param>
 		/// <param name="constructorParams">Optional parameters to use when creating the ConnectionFactory.</param>
 		/// <returns>A <see cref="IConnectionFactory" /> implementation that will be used.</returns>
 		public static IConnectionFactory CreateConnectionFactory(Uri uriProvider, params object[] constructorParams)
 		{
 			IConnectionFactory connectionFactory = null;

 			try
 			{
 				Type factoryType = GetTypeForScheme(uriProvider.Scheme);

 				// If an implementation was found, try to instantiate it.
 				if(factoryType != null)
 				{
 #if NETCF
 					// Compact framework does not allow the activator ta pass parameters to a constructor.
 					connectionFactory = (IConnectionFactory) Activator.CreateInstance(factoryType);
 					connectionFactory.BrokerUri = uriProvider;
 #else
 					object[] parameters = MakeParameterArray(uriProvider, constructorParams);
 					connectionFactory = (IConnectionFactory) Activator.CreateInstance(factoryType, parameters);
 #endif
 				}

 				if(null == connectionFactory)
 				{
 					throw new NMSConnectionException("No IConnectionFactory implementation found for connection URI: " + uriProvider);
 				}
 			}
 			catch(NMSConnectionException)
 			{
 				throw;
 			}
 			catch(Exception ex)
 			{
 				throw new NMSConnectionException("Could not create the IConnectionFactory implementation: " + ex.Message, ex);
 			}

 			return connectionFactory;
 		}

 		/// <summary>
 		/// Finds the <see cref="System.Type" /> associated with the given scheme.
 		/// </summary>
 		/// <param name="scheme">The scheme (e.g. <c>tcp</c>, <c>activemq</c> or <c>stomp</c>).</param>
 		/// <returns>The <see cref="System.Type" /> of the ConnectionFactory that will be used
 		/// to create the connection for the specified <paramref name="scheme" />.</returns>
 		private static Type GetTypeForScheme(string scheme)
 		{
 			string[] paths = GetConfigSearchPaths();
 			string assemblyFileName;
 			string factoryClassName;
 			Type factoryType = null;

 			Tracer.DebugFormat("Locating provider for scheme: {0}", scheme);
 			if(LookupConnectionFactoryInfo(paths, scheme, out assemblyFileName, out factoryClassName))
 			{
 				Assembly assembly = null;

 				Tracer.DebugFormat("Attempting to load provider assembly: {0}", assemblyFileName);
 				try
 				{
 					assembly = Assembly.Load(assemblyFileName);
 					if(null != assembly)
 					{
 						Tracer.Debug("Succesfully loaded provider.");
 					}
 				}
 				catch(Exception ex)
 				{
 					Tracer.ErrorFormat("Exception loading assembly failed: {0}", ex.Message);
 					assembly = null;
 				}

 				if(null == assembly)
 				{
 					foreach(string path in paths)
 					{
 						string fullpath = Path.Combine(path, assemblyFileName) + ".dll";

 						Tracer.DebugFormat("Looking for: {0}", fullpath);
 						if(File.Exists(fullpath))
 						{
 							Tracer.Debug("\tAssembly found!  Attempting to load...");
 							try
 							{
 								assembly = Assembly.LoadFrom(fullpath);
 							}
 							catch(Exception ex)
 							{
 								Tracer.ErrorFormat("Exception loading assembly failed: {0}", ex.Message);
 								assembly = null;
 							}

 							if(null != assembly)
 							{
 								Tracer.Debug("Successfully loaded provider.");
 								break;
 							}

 							Tracer.Debug("Failed to load provider.  Continuing search...");
 						}
 					}
 				}

 				if(null != assembly)
 				{
 #if NETCF
 					factoryType = assembly.GetType(factoryClassName, true);
 #else
 					factoryType = assembly.GetType(factoryClassName, true, true);
 #endif
 					if(null == factoryType)
 					{
 						Tracer.Fatal("Failed to load class factory from provider.");
 					}
 				}
 				else
 				{
 					Tracer.Fatal("Failed to load provider assembly.");
 				}
 			}

 			return factoryType;
 		}

 		/// <summary>
 		/// Lookup the connection factory assembly filename and class name.
 		/// Read an external configuration file that maps scheme to provider implementation.
 		/// Load XML config files named: nmsprovider-{scheme}.config
 		/// Following is a sample configuration file named nmsprovider-jms.config.  Replace
 		/// the parenthesis with angle brackets for proper XML formatting.
 		///
 		///     (?xml version="1.0" encoding="utf-8" ?)
 		///     (configuration)
 		///         (provider assembly="MyCompany.NMS.JMSProvider.dll" classFactory="MyCompany.NMS.JMSProvider.ConnectionFactory"/)
 		///     (/configuration)
 		///
 		/// This configuration file would be loaded and parsed when a connection uri with a scheme of 'jms'
 		/// is used for the provider.  In this example the connection string might look like:
 		///     jms://localhost:7222
 		///
 		/// </summary>
 		/// <param name="paths">Folder paths to look in.</param>
 		/// <param name="scheme">The scheme.</param>
 		/// <param name="assemblyFileName">Name of the assembly file.</param>
 		/// <param name="factoryClassName">Name of the factory class.</param>
 		/// <returns><c>true</c> if the configuration file for the specified <paramref name="scheme" /> could
 		/// be found; otherwise, <c>false</c>.</returns>
 		private static bool LookupConnectionFactoryInfo(string[] paths, string scheme, out string assemblyFileName, out string factoryClassName)
 		{
 			bool foundFactory = false;
 			string schemeLower = scheme.ToLower();
 			ProviderFactoryInfo pfi;

 			// Look for a custom configuration to handle this scheme.
 			string configFileName = String.Format("nmsprovider-{0}.config", schemeLower);

 			assemblyFileName = String.Empty;
 			factoryClassName = String.Empty;

 			Tracer.DebugFormat("Attempting to locate provider configuration: {0}", configFileName);
 			foreach(string path in paths)
 			{
 				string fullpath = Path.Combine(path, configFileName);
 				Tracer.DebugFormat("Looking for: {0}", fullpath);

 				try
 				{
 					if(File.Exists(fullpath))
 					{
 						Tracer.DebugFormat("\tConfiguration file found in {0}", fullpath);
 						XmlDocument configDoc = new XmlDocument();

 						configDoc.Load(fullpath);
 						XmlElement providerNode = (XmlElement) configDoc.SelectSingleNode("/configuration/provider");

 						if(null != providerNode)
 						{
 							assemblyFileName = providerNode.GetAttribute("assembly");
 							factoryClassName = providerNode.GetAttribute("classFactory");
 							if(!String.IsNullOrEmpty(assemblyFileName) && !String.IsNullOrEmpty(factoryClassName))
 							{
 								foundFactory = true;
 								Tracer.DebugFormat("Selected custom provider for {0}: {1}, {2}", schemeLower, assemblyFileName, factoryClassName);
 								break;
 							}
 						}
 					}
 				}
 				catch(Exception ex)
 				{
 					Tracer.DebugFormat("Exception while scanning {0}: {1}", fullpath, ex.Message);
 				}
 			}

 			if(!foundFactory)
 			{
 				// Check for standard provider implementations.
 				if(schemaProviderFactoryMap.TryGetValue(schemeLower, out pfi))
 				{
 					assemblyFileName = pfi.assemblyFileName;
 					factoryClassName = pfi.factoryClassName;
 					foundFactory = true;
 					Tracer.DebugFormat("Selected standard provider for {0}: {1}, {2}", schemeLower, assemblyFileName, factoryClassName);
 				}
 			}

 			return foundFactory;
 		}

 		/// <summary>
 		/// Get an array of search paths to look for config files.
 		/// </summary>
 		/// <returns>
 		/// A collection of search paths, including the current directory, the current AppDomain's
 		/// BaseDirectory and the current AppDomain's RelativeSearchPath.
 		/// </returns>
 		private static string[] GetConfigSearchPaths()
 		{
 			ArrayList pathList = new ArrayList();

 			// Check the current folder first.
 			pathList.Add("");
 #if !NETCF
 			try
 			{
 				AppDomain currentDomain = AppDomain.CurrentDomain;

 				// Check the folder the assembly is located in.
 				Assembly executingAssembly = Assembly.GetExecutingAssembly();
 				try
 				{
 					pathList.Add(Path.GetDirectoryName(executingAssembly.Location));
 				}
 				catch(Exception ex)
 				{
 					Tracer.DebugFormat("Error parsing executing assembly location: {0} : {1}", executingAssembly.Location, ex.Message);
 				}

 				if(null != currentDomain.BaseDirectory)
 				{
 					pathList.Add(currentDomain.BaseDirectory);
 				}

 				if(null != currentDomain.RelativeSearchPath)
 				{
 					pathList.Add(currentDomain.RelativeSearchPath);
 				}
 			}
 			catch(Exception ex)
 			{
 				Tracer.DebugFormat("Error configuring search paths: {0}", ex.Message);
 			}
 #endif

 			return (string[]) pathList.ToArray(typeof(string));
 		}

 		/// <summary>
 		/// Converts a <c>params object[]</c> collection into a plain <c>object[]</c>s, to pass to the constructor.
 		/// </summary>
 		/// <param name="firstParam">The first parameter in the collection.</param>
 		/// <param name="varParams">The remaining parameters.</param>
 		/// <returns>An array of <see cref="Object" /> instances.</returns>
 		private static object[] MakeParameterArray(object firstParam, params object[] varParams)
 		{
 			ArrayList paramList = new ArrayList();
 			paramList.Add(firstParam);
 			foreach(object param in varParams)
 			{
 				paramList.Add(param);
 			}

 			return paramList.ToArray();
 		}

 		/// <summary>
 		/// Creates a new connection.
 		/// </summary>
 		/// <returns>An <see cref="IConnection" /> created by the requested ConnectionFactory.</returns>
 		public IConnection CreateConnection()
 		{
 			return this.factory.CreateConnection();
 		}

 		/// <summary>
 		/// Creates a new connection with the given <paramref name="userName" /> and <paramref name="password" /> credentials.
 		/// </summary>
 		/// <param name="userName">The username to use when establishing the connection.</param>
 		/// <param name="password">The password to use when establishing the connection.</param>
 		/// <returns>An <see cref="IConnection" /> created by the requested ConnectionFactory.</returns>
 		public IConnection CreateConnection(string userName, string password)
 		{
 			return this.factory.CreateConnection(userName, password);
 		}

 		/// <summary>
 		/// Get/or set the broker Uri.
 		/// </summary>
 		public Uri BrokerUri
 		{
 			get { return ConnectionFactory.BrokerUri; }
 			set { ConnectionFactory.BrokerUri = value; }
 		}

 		/// <summary>
 		/// The actual IConnectionFactory implementation that is being used.  This implementation
 		/// depends on the scheme of the URI used when constructed.
 		/// </summary>
 		public IConnectionFactory ConnectionFactory
 		{
 			get { return factory; }
 		}

 		/// <summary>
 		/// Get/or Set the IRedeliveryPolicy instance using the IConnectionFactory implementation
 		/// that is being used.
 		/// </summary>
 		public IRedeliveryPolicy RedeliveryPolicy
 		{
 			get { return this.factory.RedeliveryPolicy; }
 			set { this.factory.RedeliveryPolicy = value; }
 		}

         /// <summary>
         /// Get/or Set the ConsumerTransformerDelegate using the IConnectionFactory implementation
         /// that is currently being used.
         /// </summary>
         public ConsumerTransformerDelegate ConsumerTransformer
         {
             get { return this.factory.ConsumerTransformer; }
             set { this.factory.ConsumerTransformer = value; }
         }

         /// <summary>
         /// Get/or Set the ProducerTransformerDelegate using the IConnectionFactory implementation
         /// that is currently being used.
         /// </summary>
         public ProducerTransformerDelegate ProducerTransformer
         {
             get { return this.factory.ProducerTransformer; }
             set { this.factory.ProducerTransformer = value; }
         }
 	}
 }
	/*
	* 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.
	*/

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.IO;
	using System.Reflection;
	using System.Xml;

	using Apache.NMS.Util;

	namespace Apache.NMS
	{
	/// <summary>
	/// Provider implementation mapping class.
	/// </summary>
	public class ProviderFactoryInfo
	{
	public string assemblyFileName;
	public string factoryClassName;

	public ProviderFactoryInfo(string aFileName, string fClassName)
	{
	assemblyFileName = aFileName;
	factoryClassName = fClassName;
	}
	}

	/// <summary>
	/// Implementation of a factory for <see cref="IConnection" /> instances.
	/// </summary>
	public class NMSConnectionFactory : IConnectionFactory
	{
	protected readonly IConnectionFactory factory;
	protected static readonly Dictionary<string, ProviderFactoryInfo> schemaProviderFactoryMap;

	/// <summary>
	/// Static class constructor
	/// </summary>
	static NMSConnectionFactory()
	{
	schemaProviderFactoryMap = new Dictionary<string, ProviderFactoryInfo>();
	schemaProviderFactoryMap["activemq"] = new ProviderFactoryInfo("Apache.NMS.ActiveMQ", "Apache.NMS.ActiveMQ.ConnectionFactory");
	schemaProviderFactoryMap["activemqnettx"] = new ProviderFactoryInfo("Apache.NMS.ActiveMQ", "Apache.NMS.ActiveMQ.NetTxConnectionFactory");
	schemaProviderFactoryMap["tcp"] = new ProviderFactoryInfo("Apache.NMS.ActiveMQ", "Apache.NMS.ActiveMQ.ConnectionFactory");
	schemaProviderFactoryMap["ems"] = new ProviderFactoryInfo("Apache.NMS.EMS", "Apache.NMS.EMS.ConnectionFactory");
	schemaProviderFactoryMap["mqtt"] = new ProviderFactoryInfo("Apache.NMS.MQTT", "Apache.NMS.MQTT.ConnectionFactory");
	schemaProviderFactoryMap["msmq"] = new ProviderFactoryInfo("Apache.NMS.MSMQ", "Apache.NMS.MSMQ.ConnectionFactory");
	schemaProviderFactoryMap["stomp"] = new ProviderFactoryInfo("Apache.NMS.Stomp", "Apache.NMS.Stomp.ConnectionFactory");
	schemaProviderFactoryMap["xms"] = new ProviderFactoryInfo("Apache.NMS.XMS", "Apache.NMS.XMS.ConnectionFactory");
	schemaProviderFactoryMap["zmq"] = new ProviderFactoryInfo("Apache.NMS.ZMQ", "Apache.NMS.ZMQ.ConnectionFactory");
	schemaProviderFactoryMap["amqp"] = new ProviderFactoryInfo("Apache.NMS.AMQP", "Apache.NMS.AMQP.ConnectionFactory");
	}

	/// <summary>
	/// The ConnectionFactory object must define a constructor that takes as a minimum a Uri object.
	/// Any additional parameters are optional, but will typically include a Client ID string.
	/// </summary>
	/// <param name="providerURI">The URI for the ActiveMQ provider.</param>
	/// <param name="constructorParams">Optional parameters to use when creating the ConnectionFactory.</param>
	public NMSConnectionFactory(string providerURI, params object[] constructorParams)
	: this(URISupport.CreateCompatibleUri(providerURI), constructorParams)
	{
	}

	/// <summary>
	/// The ConnectionFactory object must define a constructor that takes as a minimum a Uri object.
	/// Any additional parameters are optional, but will typically include a Client ID string.
	/// </summary>
	/// <param name="uriProvider">The URI for the ActiveMQ provider.</param>
	/// <param name="constructorParams">Optional parameters to use when creating the ConnectionFactory.</param>
	public NMSConnectionFactory(Uri uriProvider, params object[] constructorParams)
	{
	this.factory = CreateConnectionFactory(uriProvider, constructorParams);
	}

	/// <summary>
	/// Create a connection factory that can create connections for the given scheme in the URI.
	/// </summary>
	/// <param name="uriProvider">The URI for the ActiveMQ provider.</param>
	/// <param name="constructorParams">Optional parameters to use when creating the ConnectionFactory.</param>
	/// <returns>A <see cref="IConnectionFactory" /> implementation that will be used.</returns>
	public static IConnectionFactory CreateConnectionFactory(Uri uriProvider, params object[] constructorParams)
	{
	IConnectionFactory connectionFactory = null;

	try
	{
	Type factoryType = GetTypeForScheme(uriProvider.Scheme);

	// If an implementation was found, try to instantiate it.
	if(factoryType != null)
	{
	#if NETCF
	// Compact framework does not allow the activator ta pass parameters to a constructor.
	connectionFactory = (IConnectionFactory) Activator.CreateInstance(factoryType);
	connectionFactory.BrokerUri = uriProvider;
	#else
	object[] parameters = MakeParameterArray(uriProvider, constructorParams);
	connectionFactory = (IConnectionFactory) Activator.CreateInstance(factoryType, parameters);
	#endif
	}

	if(null == connectionFactory)
	{
	throw new NMSConnectionException("No IConnectionFactory implementation found for connection URI: " + uriProvider);
	}
	}
	catch(NMSConnectionException)
	{
	throw;
	}
	catch(Exception ex)
	{
	throw new NMSConnectionException("Could not create the IConnectionFactory implementation: " + ex.Message, ex);
	}

	return connectionFactory;
	}

	/// <summary>
	/// Finds the <see cref="System.Type" /> associated with the given scheme.
	/// </summary>
	/// <param name="scheme">The scheme (e.g. <c>tcp</c>, <c>activemq</c> or <c>stomp</c>).</param>
	/// <returns>The <see cref="System.Type" /> of the ConnectionFactory that will be used
	/// to create the connection for the specified <paramref name="scheme" />.</returns>
	private static Type GetTypeForScheme(string scheme)
	{
	string[] paths = GetConfigSearchPaths();
	string assemblyFileName;
	string factoryClassName;
	Type factoryType = null;

	Tracer.DebugFormat("Locating provider for scheme: {0}", scheme);
	if(LookupConnectionFactoryInfo(paths, scheme, out assemblyFileName, out factoryClassName))
	{
	Assembly assembly = null;

	Tracer.DebugFormat("Attempting to load provider assembly: {0}", assemblyFileName);
	try
	{
	assembly = Assembly.Load(assemblyFileName);
	if(null != assembly)
	{
	Tracer.Debug("Succesfully loaded provider.");
	}
	}
	catch(Exception ex)
	{
	Tracer.ErrorFormat("Exception loading assembly failed: {0}", ex.Message);
	assembly = null;
	}

	if(null == assembly)
	{
	foreach(string path in paths)
	{
	string fullpath = Path.Combine(path, assemblyFileName) + ".dll";

	Tracer.DebugFormat("Looking for: {0}", fullpath);
	if(File.Exists(fullpath))
	{
	Tracer.Debug("\tAssembly found! Attempting to load...");
	try
	{
	assembly = Assembly.LoadFrom(fullpath);
	}
	catch(Exception ex)
	{
	Tracer.ErrorFormat("Exception loading assembly failed: {0}", ex.Message);
	assembly = null;
	}

	if(null != assembly)
	{
	Tracer.Debug("Successfully loaded provider.");
	break;
	}

	Tracer.Debug("Failed to load provider. Continuing search...");
	}
	}
	}

	if(null != assembly)
	{
	#if NETCF
	factoryType = assembly.GetType(factoryClassName, true);
	#else
	factoryType = assembly.GetType(factoryClassName, true, true);
	#endif
	if(null == factoryType)
	{
	Tracer.Fatal("Failed to load class factory from provider.");
	}
	}
	else
	{
	Tracer.Fatal("Failed to load provider assembly.");
	}
	}

	return factoryType;
	}

	/// <summary>
	/// Lookup the connection factory assembly filename and class name.
	/// Read an external configuration file that maps scheme to provider implementation.
	/// Load XML config files named: nmsprovider-{scheme}.config
	/// Following is a sample configuration file named nmsprovider-jms.config. Replace
	/// the parenthesis with angle brackets for proper XML formatting.
	///
	/// (?xml version="1.0" encoding="utf-8" ?)
	/// (configuration)
	/// (provider assembly="MyCompany.NMS.JMSProvider.dll" classFactory="MyCompany.NMS.JMSProvider.ConnectionFactory"/)
	/// (/configuration)
	///
	/// This configuration file would be loaded and parsed when a connection uri with a scheme of 'jms'
	/// is used for the provider. In this example the connection string might look like:
	/// jms://localhost:7222
	///
	/// </summary>
	/// <param name="paths">Folder paths to look in.</param>
	/// <param name="scheme">The scheme.</param>
	/// <param name="assemblyFileName">Name of the assembly file.</param>
	/// <param name="factoryClassName">Name of the factory class.</param>
	/// <returns><c>true</c> if the configuration file for the specified <paramref name="scheme" /> could
	/// be found; otherwise, <c>false</c>.</returns>
	private static bool LookupConnectionFactoryInfo(string[] paths, string scheme, out string assemblyFileName, out string factoryClassName)
	{
	bool foundFactory = false;
	string schemeLower = scheme.ToLower();
	ProviderFactoryInfo pfi;

	// Look for a custom configuration to handle this scheme.
	string configFileName = String.Format("nmsprovider-{0}.config", schemeLower);

	assemblyFileName = String.Empty;
	factoryClassName = String.Empty;

	Tracer.DebugFormat("Attempting to locate provider configuration: {0}", configFileName);
	foreach(string path in paths)
	{
	string fullpath = Path.Combine(path, configFileName);
	Tracer.DebugFormat("Looking for: {0}", fullpath);

	try
	{
	if(File.Exists(fullpath))
	{
	Tracer.DebugFormat("\tConfiguration file found in {0}", fullpath);
	XmlDocument configDoc = new XmlDocument();

	configDoc.Load(fullpath);
	XmlElement providerNode = (XmlElement) configDoc.SelectSingleNode("/configuration/provider");

	if(null != providerNode)
	{
	assemblyFileName = providerNode.GetAttribute("assembly");
	factoryClassName = providerNode.GetAttribute("classFactory");
	if(!String.IsNullOrEmpty(assemblyFileName) && !String.IsNullOrEmpty(factoryClassName))
	{
	foundFactory = true;
	Tracer.DebugFormat("Selected custom provider for {0}: {1}, {2}", schemeLower, assemblyFileName, factoryClassName);
	break;
	}
	}
	}
	}
	catch(Exception ex)
	{
	Tracer.DebugFormat("Exception while scanning {0}: {1}", fullpath, ex.Message);
	}
	}

	if(!foundFactory)
	{
	// Check for standard provider implementations.
	if(schemaProviderFactoryMap.TryGetValue(schemeLower, out pfi))
	{
	assemblyFileName = pfi.assemblyFileName;
	factoryClassName = pfi.factoryClassName;
	foundFactory = true;
	Tracer.DebugFormat("Selected standard provider for {0}: {1}, {2}", schemeLower, assemblyFileName, factoryClassName);
	}
	}

	return foundFactory;
	}

	/// <summary>
	/// Get an array of search paths to look for config files.
	/// </summary>
	/// <returns>
	/// A collection of search paths, including the current directory, the current AppDomain's
	/// BaseDirectory and the current AppDomain's RelativeSearchPath.
	/// </returns>
	private static string[] GetConfigSearchPaths()
	{
	ArrayList pathList = new ArrayList();

	// Check the current folder first.
	pathList.Add("");
	#if !NETCF
	try
	{
	AppDomain currentDomain = AppDomain.CurrentDomain;

	// Check the folder the assembly is located in.
	Assembly executingAssembly = Assembly.GetExecutingAssembly();
	try
	{
	pathList.Add(Path.GetDirectoryName(executingAssembly.Location));
	}
	catch(Exception ex)
	{
	Tracer.DebugFormat("Error parsing executing assembly location: {0} : {1}", executingAssembly.Location, ex.Message);
	}

	if(null != currentDomain.BaseDirectory)
	{
	pathList.Add(currentDomain.BaseDirectory);
	}

	if(null != currentDomain.RelativeSearchPath)
	{
	pathList.Add(currentDomain.RelativeSearchPath);
	}
	}
	catch(Exception ex)
	{
	Tracer.DebugFormat("Error configuring search paths: {0}", ex.Message);
	}
	#endif

	return (string[]) pathList.ToArray(typeof(string));
	}

	/// <summary>
	/// Converts a <c>params object[]</c> collection into a plain <c>object[]</c>s, to pass to the constructor.
	/// </summary>
	/// <param name="firstParam">The first parameter in the collection.</param>
	/// <param name="varParams">The remaining parameters.</param>
	/// <returns>An array of <see cref="Object" /> instances.</returns>
	private static object[] MakeParameterArray(object firstParam, params object[] varParams)
	{
	ArrayList paramList = new ArrayList();
	paramList.Add(firstParam);
	foreach(object param in varParams)
	{
	paramList.Add(param);
	}

	return paramList.ToArray();
	}

	/// <summary>
	/// Creates a new connection.
	/// </summary>
	/// <returns>An <see cref="IConnection" /> created by the requested ConnectionFactory.</returns>
	public IConnection CreateConnection()
	{
	return this.factory.CreateConnection();
	}

	/// <summary>
	/// Creates a new connection with the given <paramref name="userName" /> and <paramref name="password" /> credentials.
	/// </summary>
	/// <param name="userName">The username to use when establishing the connection.</param>
	/// <param name="password">The password to use when establishing the connection.</param>
	/// <returns>An <see cref="IConnection" /> created by the requested ConnectionFactory.</returns>
	public IConnection CreateConnection(string userName, string password)
	{
	return this.factory.CreateConnection(userName, password);
	}

	/// <summary>
	/// Get/or set the broker Uri.
	/// </summary>
	public Uri BrokerUri
	{
	get { return ConnectionFactory.BrokerUri; }
	set { ConnectionFactory.BrokerUri = value; }
	}

	/// <summary>
	/// The actual IConnectionFactory implementation that is being used. This implementation
	/// depends on the scheme of the URI used when constructed.
	/// </summary>
	public IConnectionFactory ConnectionFactory
	{
	get { return factory; }
	}

	/// <summary>
	/// Get/or Set the IRedeliveryPolicy instance using the IConnectionFactory implementation
	/// that is being used.
	/// </summary>
	public IRedeliveryPolicy RedeliveryPolicy
	{
	get { return this.factory.RedeliveryPolicy; }
	set { this.factory.RedeliveryPolicy = value; }
	}

	/// <summary>
	/// Get/or Set the ConsumerTransformerDelegate using the IConnectionFactory implementation
	/// that is currently being used.
	/// </summary>
	public ConsumerTransformerDelegate ConsumerTransformer
	{
	get { return this.factory.ConsumerTransformer; }
	set { this.factory.ConsumerTransformer = value; }
	}

	/// <summary>
	/// Get/or Set the ProducerTransformerDelegate using the IConnectionFactory implementation
	/// that is currently being used.
	/// </summary>
	public ProducerTransformerDelegate ProducerTransformer
	{
	get { return this.factory.ProducerTransformer; }
	set { this.factory.ProducerTransformer = value; }
	}
	}
	}