| public static DebugFormat ( string format ) : void | ||
| format | string | |
| return | void | |
/// <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>
/// 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);
}
