private static void SaveMetaDataSection(ChoPerformanceCounter pc) { string xPath = GetXPath(pc); ChoPCMetaDataInfo metaDataInfo = pc.MetaDataInfo; using (ChoXmlDocument xmlDocument = new ChoXmlDocument(MetaDataFilepath, false, false)) { if (metaDataInfo == null) { return; } XmlNode node = xmlDocument.XmlDocument.SelectSingleNode(xPath); if (node == null) { node = xmlDocument.XmlDocument.MakeXPath(xPath); } if (node != null) { ChoXmlDocument.SetOuterXml(node, metaDataInfo.ToXml()); xmlDocument.Save(); } } }
private void Initialize() { if (_isInitialized) { return; } lock (_padLock) { if (_isInitialized) { return; } try { ChoXmlDocument.CreateXmlFileIfEmpty(MetaDataFilePath); Refresh(); } finally { _isInitialized = true; } } }
private void SaveMetaDataSection(T pc) { string xPath = pc.NodeLocateXPath; TMetaDataInfo metaDataInfo = pc.MetaDataInfo; using (ChoXmlDocument xmlDocument = new ChoXmlDocument(MetaDataFilePath)) { if (metaDataInfo == null) { return; } XmlNode node = xmlDocument.XmlDocument.SelectSingleNode(xPath); if (node == null) { node = xmlDocument.XmlDocument.MakeXPath(pc.NodeCreateXPath); } if (node != null) { ChoXmlDocument.SetOuterXml(node, metaDataInfo.ToXml()); xmlDocument.Save(); } } }
private static void SetMetaDataSection(Type cmdLineObjType, ChoObjectInfo objectInfo) { if (cmdLineObjType == null) { return; } string elementPath = cmdLineObjType.Name; using (ChoXmlDocument xmlDocument = new ChoXmlDocument(_metaDataFilepath)) { if (elementPath.IsNullOrEmpty()) { return; } XmlNode node = xmlDocument.XmlDocument.SelectSingleNode(elementPath); if (node == null) { node = xmlDocument.XmlDocument.MakeXPath(elementPath); } if (node != null) { xmlDocument.XmlDocument.InnerXml = ChoXmlDocument.AppendToInnerXml(node, objectInfo.ToXml()); xmlDocument.Save(); } } }
private static void Refresh() { try { LoadFile(); } catch (Exception ex) { ChoTrace.Error(ex); try { string newFile = ChoPath.AddExtension(MetaDataFilepath, ChoReservedFileExt.Err); if (File.Exists(newFile)) { File.Delete(newFile); } File.Move(MetaDataFilepath, newFile); ChoXmlDocument.CreateXmlFileIfEmpty(MetaDataFilepath); LoadFile(); } catch (Exception innerEx) { ChoTrace.Error(innerEx); } } }
private static void Initialize() { if (_isInitialized) { return; } lock (_padLock) { if (_isInitialized) { return; } try { MetaDataFilepath = ConfigurationManager.AppSettings[PC_METADATA_FILEPATH_TAG]; if (MetaDataFilepath.IsNullOrWhiteSpace() || !File.Exists(MetaDataFilepath)) { MetaDataFilepath = ChoPath.AddExtension(Path.ChangeExtension(Path.Combine(Path.GetDirectoryName(ChoApplication.ApplicationConfigFilePath), Path.GetFileNameWithoutExtension(ChoApplication.ApplicationConfigFilePath)), "perf"), ChoReservedFileExt.MetaData); } ChoXmlDocument.CreateXmlFileIfEmpty(MetaDataFilepath); Refresh(); } finally { _isInitialized = true; } } }
private static void SetMetaDataSection(ChoCommandLineArgObject cmdLineArgObject, ChoPropertyInfos propertyInfos) { return; if (cmdLineArgObject == null) { return; } string elementPath = cmdLineArgObject.GetType().Name; using (ChoXmlDocument xmlDocument = new ChoXmlDocument(_metaDataFilepath)) { if (elementPath.IsNullOrEmpty()) { return; } XmlNode node = xmlDocument.XmlDocument.SelectSingleNode(elementPath); if (node == null) { node = xmlDocument.XmlDocument.MakeXPath(elementPath); } if (node != null) { xmlDocument.XmlDocument.InnerXml = ChoXmlDocument.AppendToInnerXml(node, propertyInfos.ToXml()); xmlDocument.Save(); } } }
protected void PersistAsNameSpaceAwareXml(object data, ChoDictionaryService <string, object> stateInfo) { string configFilePath = stateInfo[UNDERLYING_CONFIG_PATH] as string; if (configFilePath.IsNullOrWhiteSpace()) { return; } ChoXmlDocument.CreateXmlFileIfEmpty(configFilePath); using (ChoXmlDocument xmlDocument = new ChoXmlDocument(GetFullPath(configFilePath))) { PersistConfigSectionDefinition(xmlDocument.XmlDocument, data); XmlNode configNode = xmlDocument.XmlDocument.MakeXPath(ConfigElement.ConfigElementPath); if (configNode != null) { string configXml = ToXml(data); if (configXml.IsNull()) { return; } ChoXmlDocument.SetNamespaceAwareOuterXml(configNode, configXml, ChoXmlDocument.CinchooNSURI); } } }
private void LoadFile() { using (ChoXmlDocument xmlDocument = new ChoXmlDocument(MetaDataFilePath)) { RootNode = xmlDocument.XmlDocument.DocumentElement; _includeFiles = xmlDocument != null ? xmlDocument.IncludeFiles : null; } }
private static void LoadFile() { using (ChoXmlDocument xmlDocument = new ChoXmlDocument(MetaDataFilepath, false, false)) { _rootNode = xmlDocument.XmlDocument.DocumentElement; _includeFiles = xmlDocument != null ? xmlDocument.IncludeFiles : null; } }
private static void LoadConfigurationFile() { if (_appXmlDocument != null) { _appXmlDocument.Dispose(); _appXmlDocument = null; } _appXmlDocument = new ChoXmlDocument(_appConfigPath); _appIncludeConfigFilePaths = _appXmlDocument.IncludeFiles; if (_appXmlDocument != null && _appIncludeConfigFilePaths != null && _appIncludeConfigFilePaths.Length > 0) { _appXmlDocument.XmlDocument.Save(_appConfigPath); } if (_configurationChangeWatcher == null) { _configurationChangeWatcher = new ChoAppConfigurationChangeFileWatcher("configurations", _appConfigPath, _appIncludeConfigFilePaths); _configurationChangeWatcher.SetConfigurationChangedEventHandler(_key, new ChoConfigurationChangedEventHandler(_configurationChangeWatcher_ConfigurationChanged)); ChoEnvironmentSettings.SetEnvironmentChangedEventHandlerNoCall("configurations", (sender, e) => { ChoAppConfigurationChangeFileWatcher configurationChangeWatcher = _configurationChangeWatcher; _configurationChangeWatcher = null; _configurationChangeWatcher_ConfigurationChanged(null, null); configurationChangeWatcher.OnConfigurationChanged(); configurationChangeWatcher.Dispose(); configurationChangeWatcher = null; }); } else { _configurationChangeWatcher.Reset(_appConfigPath, _appIncludeConfigFilePaths); } if (_systemConfigurationChangeWatcher == null) { try { _systemConfigurationChangeWatcher = new ChoConfigurationChangeFileWatcher("systemConfigurations", AppDomain.CurrentDomain.SetupInformation.ConfigurationFile); _systemConfigurationChangeWatcher.SetConfigurationChangedEventHandler(_key, new ChoConfigurationChangedEventHandler(_systemConfigurationChangeWatcher_ConfigurationChanged)); } catch (Exception ex) { ChoApplication.Trace(ex.ToString()); } } //Remove namespaces if (_appXmlDocument != null && _appIncludeConfigFilePaths != null && _appIncludeConfigFilePaths.Length > 0) { XDocument doc = XDocument.Load(_appConfigPath, LoadOptions.PreserveWhitespace); doc.Descendants().Attributes().Where(a => a.IsNamespaceDeclaration).Remove(); doc.Save(_appConfigPath, SaveOptions.DisableFormatting); } _configuration = _appXmlDocument.XmlDocument.DocumentElement.ToObject <ChoConfiguration>(); _configuration.Initialize(); }
public static void RestoreAppConfig() { if (File.Exists(AppConfigFilePath)) { if (_appXmlDocument != null && _appXmlDocument.HasIncludeComments) { ChoXmlDocument.ContractNSave(_appXmlDocument, AppConfigFilePath); } } }
internal static void RestoreAppConfig() { if (File.Exists(ChoGlobalApplicationSettings.Me.ApplicationConfigFilePath)) { if (_appXmlDocument != null && _appXmlDocument.HasIncludeComments) { ChoXmlDocument.ContractNSave(_appXmlDocument, ChoGlobalApplicationSettings.Me.ApplicationConfigFilePath); } } }
public override object Load(ChoBaseConfigurationElement configElement, XmlNode node) { base.Load(configElement, node); //if (configElement.ConfigFilePath.IsNullOrWhiteSpace()) // UnderlyingConfigFilePath = ChoConfigurationManager.GetConfigFile(node); //else // UnderlyingConfigFilePath = configElement.ConfigFilePath; UnderlyingConfigFilePath = ChoConfigurationManager.GetConfigFile(node); if (UnderlyingConfigFilePath.IsNullOrWhiteSpace()) { configElement[ChoConfigurationConstants.FORCE_PERSIST] = true; UnderlyingConfigFilePath = configElement.ConfigFilePath; } ConfigElement[UNDERLYING_CONFIG_PATH] = UnderlyingConfigFilePath; ConfigFilePath = GetFullPath(UnderlyingConfigFilePath); if (IsAppConfigFile) { if (!configElement.ConfigFilePath.IsNullOrWhiteSpace()) { UnderlyingConfigFilePath = configElement.ConfigFilePath; ConfigFilePath = GetFullPath(UnderlyingConfigFilePath); } } if (node != null && !IsAppConfigFile) { if (configElement.Persistable) { ChoXmlDocument.CreateXmlFileIfEmpty(ConfigFilePath); } using (ChoXmlDocument document = new ChoXmlDocument(ConfigFilePath)) { string nodeName = configElement.ConfigElementPath; IncludeFilePaths = document.IncludeFiles; if (document.XmlDocument != null && document.XmlDocument.DocumentElement != null) { ChoConfiguration configuration = document.XmlDocument.DocumentElement.ToObject <ChoConfiguration>(); if (configuration != null) { ConfigNode = ChoXmlDocument.GetXmlNode(nodeName, configuration.RestOfXmlDocumentElements); } } } } return(null); }
public void OnConfigurationMetaDataChanged() { ChoConfigurationMetaDataChangeEventHandler configurationMetaDataChangeEvent = ConfigurationMetaDataChangedEvent; if (configurationMetaDataChangeEvent != null) { using (ChoXmlDocument document = new ChoXmlDocument(MetaDataFileName, false, true)) { configurationMetaDataChangeEvent(document.XmlDocument.SelectSingleNode(@"//{0}".FormatString(ConfigSectionName))); } } }
public override void Persist(ChoConfigSectionObjectMap configSectionObjectMap) { StringBuilder config = new StringBuilder(); Hashtable keyValues = configSectionObjectMap.ToHashtable(); foreach (string key in keyValues.Keys) { if (keyValues[key] != null) { config.AppendFormat("<add key=\"{0}\" value=\"{1}\" />{2}", key, keyValues[key].ToString(), Environment.NewLine); } } File.WriteAllText(_configPath, ChoXmlDocument.SetInnerXml(_configPath, ConfigSectionName, config.ToString())); }
protected void PersistAsPlainXml(object data, ChoDictionaryService <string, object> stateInfo) { using (ChoXmlDocument xmlDocument = new ChoXmlDocument(stateInfo[UNDERLYING_CONFIG_PATH] as string)) { PersistConfigSectionDefinition(xmlDocument.XmlDocument, data); XmlNode configNode = xmlDocument.XmlDocument.MakeXPath(ConfigElement.ConfigElementPath); if (configNode != null) { string configXml = ToXml(data); if (configXml.IsNullOrEmpty()) { return; } ChoXmlDocument.SetOuterXml(configNode, configXml); } } }
public static bool IsConfigXmlModified(string configSectionPath, XmlNode oldNode) { XmlNode node = ChoXmlDocument.GetXmlNode(configSectionPath, _configuration.RestOfXmlDocumentElements); if (object.ReferenceEquals(node, oldNode)) { return(false); } if (object.ReferenceEquals(oldNode, null)) { return(true); } if (object.ReferenceEquals(node, null)) { return(true); } return(node.OuterXml != oldNode.OuterXml); }
public static void SetMetaDataSection(ChoBaseConfigurationElement configElement) { if (configElement == null) { return; } if (ChoObject.Equals <ChoBaseConfigurationMetaDataInfo>(configElement.MetaDataInfo, GetMetaDataSection(configElement))) { return; } string configElementPath = configElement.ConfigElementPath; ChoBaseConfigurationMetaDataInfo configurationMetaDataInfo = configElement.MetaDataInfo; configurationMetaDataInfo = ChoObject.Merge <ChoBaseConfigurationMetaDataInfo>(configurationMetaDataInfo, GetDefaultMetaDataInfo(configElement)); if (configurationMetaDataInfo == null) { return; } using (ChoXmlDocument xmlDocument = new ChoXmlDocument(_metaDataFilepath)) { if (configElementPath.IsNullOrEmpty()) { return; } XmlNode node = xmlDocument.XmlDocument.SelectSingleNode(configElementPath); if (node == null) { node = xmlDocument.XmlDocument.MakeXPath(configElementPath); } if (node != null) { ChoXmlDocument.SetOuterXml(node, configurationMetaDataInfo.ToXml()); xmlDocument.XmlDocument.InnerXml = ChoXmlDocument.AppendToInnerXml(node, GetPropertyInfos(configElement).ToXml()); xmlDocument.Save(); } } }
private static void Refresh() { try { lock (_padLock) { //_propDict.Clear(); } if (ChoMetaDataFilePathSettings.Me != null) { _pbsDataFilepath = ChoMetaDataFilePathSettings.Me.OverridenPBSDataFilePath; } if (!ChoAppFrxSettings.Me.DisableMetaDataConfig) { ChoXmlDocument.CreateXmlFileIfEmpty(_pbsDataFilepath); _pbsDataChangeWatcher = new ChoAppConfigurationChangeFileWatcher(PBS_DATA_KEY, _pbsDataFilepath, _includeFiles); _pbsDataChangeWatcher.SetConfigurationChangedEventHandler(PBS_DATA_FILE_WATCHER_KEY, (sender, e) => { Refresh(); }); } if (!_pbsDataFilepath.IsNullOrWhiteSpace() && File.Exists(_pbsDataFilepath)) { using (ChoXmlDocument xmlDocument = new ChoXmlDocument(_pbsDataFilepath)) { _rootNode = xmlDocument.XmlDocument.DocumentElement; _includeFiles = xmlDocument != null ? xmlDocument.IncludeFiles : null; } } BuildProfileBackingStores(); } catch (Exception ex) { ChoTrace.Error(ex.ToString()); //throw; } }
private static void StopGlobalQueuedExecutionService() { if (_configurationChangeWatcher != null) { _configurationChangeWatcher.Dispose(); } _configurationChangeWatcher = null; if (_systemConfigurationChangeWatcher != null) { _systemConfigurationChangeWatcher.Dispose(); } _systemConfigurationChangeWatcher = null; if (_appXmlDocument != null) { _appXmlDocument.Dispose(); _appXmlDocument = null; } }
internal static object GetConfig(Type configObjectType, string configSectionPath, Type defaultConfigSectionHandlerType, ChoBaseConfigurationElement configElement) { if (_configuration == null) { return(null); } ChoConfigurationSection configurationSection = ChoConfigurationManager.GetConfigSection(configSectionPath); XmlNode[] restOfXmlElements = null; Type configSectionHandlerType = defaultConfigSectionHandlerType; if (configurationSection != null) { restOfXmlElements = configurationSection.RestOfXmlElements; if (!configurationSection.Type.IsNullOrWhiteSpace()) { configSectionHandlerType = ChoType.GetType(configurationSection.Type); } } configElement.ConfigSectionHandlerType = configSectionHandlerType; if (!typeof(IChoConfigurationSectionHandler).IsAssignableFrom(configSectionHandlerType)) { throw new ChoConfigurationException("Configuration section handler type should be of IChoConfigurationSectionHandler type."); } if (typeof(IChoNullConfigurationSectionableHandler).IsAssignableFrom(configSectionHandlerType)) { return(ChoType.CreateInstance <IChoConfigurationSectionHandler>(configSectionHandlerType).Create(configObjectType, null, restOfXmlElements, configElement)); } else { XmlNode node = ChoXmlDocument.GetXmlNode(configSectionPath, _configuration.RestOfXmlDocumentElements); //if (node != null) return(ChoType.CreateInstance <IChoConfigurationSectionHandler>(configSectionHandlerType).Create(configObjectType, node, restOfXmlElements, configElement)); } //return new ChoDefaultApplicationConfigSection(configObjectType); }
private static void Refresh() { try { lock (_padLock) { _propDict.Clear(); } if (ChoMetaDataFilePathSettings.Me != null) { _metaDataFilepath = ChoMetaDataFilePathSettings.Me.OverridenConfigurationMetaDataFilePath; } if (!ChoAppFrxSettings.Me.DisableMetaDataConfig) { ChoXmlDocument.CreateXmlFileIfEmpty(_metaDataFilepath); _configurationChangeWatcher = new ChoAppConfigurationChangeFileWatcher("meta-data_configurations", _metaDataFilepath, _includeFiles); _configurationChangeWatcher.SetConfigurationChangedEventHandler("ChoMetaDataManager_Watcher", (sender, e) => { Refresh(); }); } if (!_metaDataFilepath.IsNullOrWhiteSpace() && File.Exists(_metaDataFilepath)) { using (ChoXmlDocument xmlDocument = new ChoXmlDocument(_metaDataFilepath)) { _rootNode = xmlDocument.XmlDocument.DocumentElement; _includeFiles = xmlDocument != null ? xmlDocument.IncludeFiles : null; } } } catch (Exception ex) { ChoTrace.Error(ex.ToString()); //throw; } }
private void Refresh() { if (ChoAppFrxSettings.Me.DisableMetaDataConfig) { return; } try { LoadFile(); } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { ChoTrace.Error(ex); try { string newFile = ChoPath.AddExtension(MetaDataFilePath, ChoReservedFileExt.Err); if (File.Exists(newFile)) { File.Delete(newFile); } File.Move(MetaDataFilePath, newFile); ChoXmlDocument.CreateXmlFileIfEmpty(MetaDataFilePath); LoadFile(); } catch (Exception innerEx) { ChoTrace.Error(innerEx); } } }
public override void Persist(object data, ChoDictionaryService <string, object> stateInfo) { ChoXmlDocument.CreateXmlFileIfEmpty(ConfigFilePath); string backupConfigFilePath = String.Format("{0}.{1}", ConfigFilePath, ChoReservedFileExt.Cho); try { //Write meta-data info ChoConfigurationMetaDataManager.SetMetaDataSection(ConfigElement); if (!IsAppConfigFile) { if (File.Exists(backupConfigFilePath)) { File.SetAttributes(backupConfigFilePath, FileAttributes.Archive); } File.Copy(ConfigFilePath, backupConfigFilePath, true); if (File.Exists(backupConfigFilePath)) { File.SetAttributes(backupConfigFilePath, FileAttributes.Hidden); } } } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { ConfigElement.Log(ex.ToString()); } try { //if seperate config file maintained, make a link in the application configuration if (IsConfigReferenceDataChanged(stateInfo)) { using (ChoXmlDocument xmlDocument = new ChoXmlDocument(ChoGlobalApplicationSettings.Me.ApplicationConfigFilePath)) { XmlNode configNode = xmlDocument.XmlDocument.MakeXPath(ConfigElement.ConfigElementPath); if (configNode != null) { if (!IsAppConfigFile) { string configXml = @"<{0} {1}=""{2}"" {3}=""{4}"" />".FormatString(ConfigSectionName, ChoConfigurationManager.PathToken, UnderlyingConfigFilePath, ChoXmlDocument.CinchoNSToken, ChoXmlDocument.CinchooNSURI); ChoXmlDocument.SetNamespaceAwareOuterXml(configNode, configXml, ChoXmlDocument.CinchooNSURI); } } } } PersistConfigData(data, stateInfo); } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { ConfigElement.Log(ex.ToString()); if (!IsAppConfigFile) { File.Copy(backupConfigFilePath, ConfigFilePath, true); } } }
internal static void OpenExeConfiguration() { //Expand Application configuration file string appConfigPath = AppConfigFilePath; // AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; if (!File.Exists(appConfigPath)) { return; } ChoFile.SetReadOnly(appConfigPath, false); if (_configurationChangeWatcher != null) { RestoreAppConfig(); _configurationChangeWatcher.StopWatching(); _configurationChangeWatcher = null; } //backup the current configuration string backupConfigFilePath = String.Format("{0}.cho", appConfigPath); File.Copy(appConfigPath, backupConfigFilePath, true); try { _appXmlDocument = new ChoXmlDocument(appConfigPath, false, true); _appIncludeConfigFilePaths = _appXmlDocument.IncludeFiles; if (_appXmlDocument != null && _appIncludeConfigFilePaths != null && _appIncludeConfigFilePaths.Length > 0) { _appXmlDocument.XmlDocument.Save(appConfigPath); } _configurationChangeWatcher = new ChoAppConfigurationChangeFileWatcher(ChoConfigurationManager.AppConfigFilePath, "Configurations"); _configurationChangeWatcher.SetConfigurationChangedEventHandler(_key, new ChoConfigurationChangedEventHandler(_configurationChangeWatcher_ConfigurationChanged)); //Remove namespaces if (_appXmlDocument != null && _appIncludeConfigFilePaths != null && _appIncludeConfigFilePaths.Length > 0) { XDocument doc = XDocument.Load(appConfigPath, LoadOptions.PreserveWhitespace); doc.Descendants().Attributes().Where(a => a.IsNamespaceDeclaration).Remove(); doc.Save(appConfigPath, SaveOptions.DisableFormatting); } _configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); //TODO: use XmlDocument to expand if (ChoEnvironmentSettings.HasAppConfigPathSpecified()) { appConfigPath = ChoEnvironmentSettings.GetAppConfigPath(); if (!String.IsNullOrEmpty(appConfigPath)) { _configuration = ConfigurationManager.OpenExeConfiguration(appConfigPath); } } } catch { //Rollback the configuration file File.Copy(backupConfigFilePath, appConfigPath, true); throw; } }
static void _configurationChangeWatcher_ConfigurationChanged(object sender, ChoConfigurationChangedEventArgs e) { _appXmlDocument = new ChoXmlDocument(AppConfigFilePath, false, true); _appIncludeConfigFilePaths = _appXmlDocument.IncludeFiles; }
private void Load(string sharedEnvironmentConfigFilePath) { BaseAppConfigDirectory = null; DefaultEnvironment = null; EnvironmentDetails = null; string backupSharedEnvironmentConfigFilePath = null; XmlDocument doc = new XmlDocument(); if (!String.IsNullOrEmpty(sharedEnvironmentConfigFilePath) && File.Exists(sharedEnvironmentConfigFilePath)) { ChoApplication.Trace(true, "Using shared environment config file: {0}".FormatString(sharedEnvironmentConfigFilePath)); backupSharedEnvironmentConfigFilePath = "{0}.{1}".FormatString(sharedEnvironmentConfigFilePath, ChoReservedFileExt.Cho); try { if (File.Exists(backupSharedEnvironmentConfigFilePath)) { File.SetAttributes(backupSharedEnvironmentConfigFilePath, FileAttributes.Archive); } using (ChoXmlDocument xmlDoc = new ChoXmlDocument(sharedEnvironmentConfigFilePath)) { doc = xmlDoc.XmlDocument; } //doc.Load(sharedEnvironmentConfigFilePath); doc.Save(backupSharedEnvironmentConfigFilePath); if (File.Exists(backupSharedEnvironmentConfigFilePath)) { File.SetAttributes(backupSharedEnvironmentConfigFilePath, FileAttributes.Hidden); } } catch (Exception ex) { ChoApplication.Trace(true, "Error loading shared environment config file: {0}.".FormatString(sharedEnvironmentConfigFilePath)); ChoApplication.Trace(true, ex.ToString()); doc = LoadBackupSharedEnvironmentConfigFile(backupSharedEnvironmentConfigFilePath); } } else if (ChoApplication.GetSharedEnvironmentConfigXml != null) { string xml = ChoApplication.GetSharedEnvironmentConfigXml(); backupSharedEnvironmentConfigFilePath = "SharedEnvironments.{0}.{1}".FormatString(ChoReservedFileExt.Xml, ChoReservedFileExt.Cho); if (!xml.IsNullOrWhiteSpace()) { ChoApplication.Trace(true, "Using shared environment xml:"); ChoApplication.Trace(true, xml); try { doc.LoadXml(xml); doc.Save(backupSharedEnvironmentConfigFilePath); } catch (Exception ex) { ChoApplication.Trace(true, "Error loading shared environment config xml."); ChoApplication.Trace(true, ex.ToString()); doc = LoadBackupSharedEnvironmentConfigFile(backupSharedEnvironmentConfigFilePath); } } } LoadXml(doc); }
private static void OpenConfiguration(string appConfigPath, bool doBackup) { if (_appConfigPath != appConfigPath) { Trace.TraceInformation("Using AppConfigPath: {0}".FormatString(appConfigPath)); } _appConfigPath = appConfigPath; if (_appConfigPath.IsNullOrWhiteSpace()) { Trace.TraceError("Empty AppConfigPath passed."); return; } ChoFile.SetReadOnly(_appConfigPath, false); if (_configurationChangeWatcher != null) { RestoreAppConfig(); //_configurationChangeWatcher.StopWatching(); } //if (_systemConfigurationChangeWatcher != null) //{ // _systemConfigurationChangeWatcher.StopWatching(); // _systemConfigurationChangeWatcher = null; //} ChoXmlDocument.CreateXmlFileIfEmpty(_appConfigPath); //backup the current configuration string backupConfigFilePath = String.Format("{0}.{1}", _appConfigPath, ChoReservedFileExt.Cho); try { LoadConfigurationFile(); if (doBackup) { if (File.Exists(backupConfigFilePath)) { File.SetAttributes(backupConfigFilePath, FileAttributes.Archive); } File.Copy(_appConfigPath, backupConfigFilePath, true); if (File.Exists(backupConfigFilePath)) { File.SetAttributes(backupConfigFilePath, FileAttributes.Hidden); } } } catch (Exception ex) { Trace.TraceError(ex.ToString()); if (_appXmlDocument != null) { _appXmlDocument.Dispose(); _appXmlDocument = null; } try { //Rollback the configuration file if (doBackup) { File.Copy(backupConfigFilePath, _appConfigPath, true); } LoadConfigurationFile(); } catch { } } finally { if (_configurationChangeWatcher != null) { _configurationChangeWatcher.StartWatching(); } if (_systemConfigurationChangeWatcher != null) { _systemConfigurationChangeWatcher.StartWatching(); } } }
public override void Persist(ChoConfigSectionObjectMap configSectionObjectMap) { File.WriteAllText(_configPath, ChoXmlDocument.SetOuterXml(_configPath, ConfigSectionName, ChoObject.ToXmlString(configSectionObjectMap.ConfigObject))); }