/// <summary>
/// Initialize this client environment from the specified configuration file and version
/// using the configuration parser.
/// </summary>
/// <param name="parser">Configuration parser to use.</param>
/// <param name="configfile">Configuration file path.</param>
/// <param name="version">Configuration version (expected)</param>
/// <param name="password">Password, if configuration has encrypted nodes.</param>
protected void Init(AbstractConfigParser parser, string configfile,
Version version, string password = null)
{
try
{
LogUtils.Info(String.Format(
"Initializing Client Environment : With Configuration file [{0}]...",
configfile));
Uri path = new Uri(NetUtils.FilePathToFileUrl(configfile));
AbstractReader reader = ConfigProviderFactory.GetReader(path);
if (reader == null)
{
throw new ConfigurationException(String.Format("Failed to get reader. [URI={0}]", path.ToString()));
}
parser.Parse(ConfigName, reader,
version,
null, password);
__configuration = parser.GetConfiguration();
if (__configuration == null)
{
throw new ConfigurationException(String.Format(
"Error parsing configuration : NULL configuration read. [file={0}]",
configfile));
}
PostInit();
UpdateState(EEnvState.Initialized);
}
catch (Exception e)
{
throw new ConfigurationException(e);
}
}
/// <summary>
/// Load a configuration from local/remote location.
/// </summary>
/// <param name="configName">Configuration name</param>
/// <param name="configUri">Configuration File URI</param>
/// <param name="configType">Configuration Type</param>
/// <param name="version">Configuration Version (expected)</param>
/// <param name="settings">Configuration Settings</param>
/// <param name="password">Password (if required)</param>
/// <returns>Loaded Configruation</returns>
public Configuration Load(string configName, string configUri,
EConfigType configType, Version version,
ConfigurationSettings settings, string password = null)
{
Configuration config = null;
if (!loadedConfigs.ContainsKey(configName))
{
lock (loadedConfigs)
{
if (!loadedConfigs.ContainsKey(configName))
{
config = loader.Load(configName, configUri, configType, version, settings, password);
ConfigLoaded(config);
}
}
}
config = loadedConfigs[configName];
if (!config.Header.Version.Equals(version))
{
throw new ConfigurationException(String.Format("Versions not compatible. [expected=%s][actual=%s]",
version.ToString(), config.Header.Version.ToString()));
}
return(config);
}
/// <summary>
/// Load a configuration from local/remote location.
/// Will load using default settings.
/// </summary>
/// <param name="configName">Configuration name</param>
/// <param name="configUri">Configuration File URI</param>
/// <param name="configType">Configuration Type</param>
/// <param name="version">Configuration Version (expected)</param>
/// <param name="password">Password (if required)</param>
/// <returns>Loaded Configruation</returns>
public Configuration Load(string configName, string configUri,
EConfigType configType, Version version,
string password = null)
{
ConfigurationSettings settings = new ConfigurationSettings();
return(Load(configName, configUri, configType, version, settings, password));
}
/// <summary>
/// Load a configuration from local file.
/// </summary>
/// <param name="configName">Configuration name</param>
/// <param name="configFile">Configuration File Path</param>
/// <param name="version">Configuration Version (expected)</param>
/// <param name="settings">Configuration Settings</param>
/// <param name="password">Password (if required)</param>
/// <returns>Loaded Configruation</returns>
public Configuration Load(string configName, string configFile,
Version version, ConfigurationSettings settings,
string password = null)
{
Preconditions.CheckArgument(configName);
Preconditions.CheckArgument(configFile);
Preconditions.CheckArgument(version);
LogUtils.Info(String.Format("Loading Configuration. [name={0}][version={1}][file={2}]", configName, version.ToString(), configFile));
using (FileReader reader = new FileReader(configFile))
{
AbstractConfigParser parser = ConfigProviderFactory.GetParser(configFile);
Postconditions.CheckCondition(parser);
parser.Parse(configName, reader, version, settings, password);
return(parser.GetConfiguration());
}
}
/// <summary>
/// Initialize this client environment from the specified configuration file and version.
/// </summary>
/// <param name="configfile">Configuration file path.</param>
/// <param name="type">Configuration file type (in-case file type cannot be deciphered).</param>
/// <param name="version">Configuration version (expected)</param>
/// <param name="password">Password, if configuration has encrypted nodes.</param>
protected void Init(string configfile,
EConfigType type,
Version version, string password = null)
{
try
{
AbstractConfigParser parser = ConfigProviderFactory.GetParser(type);
if (parser == null)
{
throw new ConfigurationException(String.Format(
"Cannot get configuration parser instance. [file={0}]",
configfile));
}
Init(parser, configfile, version, password);
}
catch (Exception e)
{
state.SetError(e);
throw new ConfigurationException(e);
}
}
/// <summary>
/// Initialize this client environment from the specified configuration file and version.
/// </summary>
/// <param name="configfile">Configuration file path</param>
/// <param name="version">Configuration version (expected)</param>
/// <param name="password">Password, if configuration has encrypted nodes.</param>
protected void Init(string configfile, Version version, string password = null)
{
Preconditions.CheckArgument(configfile);
Preconditions.CheckArgument(version);
try
{
AbstractConfigParser parser = ConfigProviderFactory.GetParser(configfile);
if (parser == null)
{
throw new ConfigurationException(String.Format("Failed to get configuration parser. [config file={0}]", configfile));
}
Init(parser, configfile, version, password);
}
catch (Exception ex)
{
LogUtils.Debug(ex.Message);
state.SetError(ex);
throw ex;
}
}
private Configuration GetConfiguration()
{
if (configuration == null)
{
try
{
Properties properties = new Properties();
properties.Load(CONFIG_BASIC_PROPS_FILE);
string cname = properties.GetProperty(CONFIG_PROP_NAME);
Assert.False(String.IsNullOrWhiteSpace(cname));
string cfile = properties.GetProperty(CONFIG_PROP_FILENAME);
Assert.False(String.IsNullOrWhiteSpace(cfile));
string version = properties.GetProperty(CONFIG_PROP_VERSION);
Assert.False(String.IsNullOrWhiteSpace(version));
LogUtils.Info(String.Format("Reading Configuration: [file={0}][version={1}]", cfile, version));
using (FileReader reader = new FileReader(cfile))
{
reader.Open();
XmlConfigParser parser = new XmlConfigParser();
ConfigurationSettings settings = new ConfigurationSettings();
settings.DownloadOptions = EDownloadOptions.LoadRemoteResourcesOnStartup;
parser.Parse(cname, reader, Version.Parse(version), settings);
configuration = parser.GetConfiguration();
return(configuration);
}
}
catch (Exception ex)
{
LogUtils.Error(ex);
throw ex;
}
}
return(configuration);
}
