private static void EnsureConfigurationSystem() { lock (s_initLock) { if (s_initState < InitState.Usable) { s_initState = InitState.Started; try { try { s_configSystem = new ClientConfigurationSystem(); s_initState = InitState.Usable; } catch (Exception exception) { s_initError = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_client_config_init_error"), exception); throw s_initError; } } catch { s_initState = InitState.Completed; throw; } } } }
private static void EnsureConfigurationSystem() { // If a configuration system has not yet been set, // create the DefaultConfigurationSystem for exe's. lock (s_initLock) { if (s_initState < InitState.Usable) { s_initState = InitState.Started; try { try { // Create the system, but let it initialize itself // when GetConfig is called, so that it can handle its // own re-entrancy issues during initialization. // When initialization is complete, the DefaultConfigurationSystem // will call CompleteConfigInit to mark initialization as // having completed. // Note: the ClientConfigurationSystem has a 2-stage initialization, // and that's why s_initState isn't set to InitState.Completed yet. s_configSystem = new ClientConfigurationSystem(); s_initState = InitState.Usable; } catch (Exception e) { s_initError = new ConfigurationErrorsException(SR.GetString(SR.Config_client_config_init_error), e); throw s_initError; } } catch { s_initState = InitState.Completed; throw; } } } }
/* invoked from System.Web */ internal static IInternalConfigSystem ChangeConfigurationSystem(IInternalConfigSystem newSystem) { if (newSystem == null) { throw new ArgumentNullException("newSystem"); } lock (lockobj) { // KLUDGE!! We need that when an assembly loaded inside an ASP.NET // domain does OpenExeConfiguration ("") - we must return the path // to web.config in that instance. string t = newSystem.GetType().ToString(); if (String.Compare(t, "System.Web.Configuration.HttpConfigurationSystem", StringComparison.OrdinalIgnoreCase) == 0) { systemWebInUse = true; } else { systemWebInUse = false; } IInternalConfigSystem old = configSystem; configSystem = newSystem; return(old); } }
public virtual void SubstituteSystemConfiguration(IConfigurationFactory factory, IList<string> fileNames) { if (OriginalConfiguration != null) throw new InvalidOperationException("System default configuration already substituted."); OriginalConfiguration = SubstituteConfigurationSystem(factory, fileNames); }
/// <summary> /// Re-initializes the ConfigurationManager, allowing us to merge in the settings from others app.Config /// </summary> public static void Install() { FieldInfo[] fiStateValues = null; Type tInitState = typeof(System.Configuration.ConfigurationManager).GetNestedType("InitState", BindingFlags.NonPublic); if (null != tInitState) { fiStateValues = tInitState.GetFields(); } FieldInfo fiInit = typeof(System.Configuration.ConfigurationManager).GetField("s_initState", BindingFlags.NonPublic | BindingFlags.Static); FieldInfo fiSystem = typeof(System.Configuration.ConfigurationManager).GetField("s_configSystem", BindingFlags.NonPublic | BindingFlags.Static); if (fiInit != null && fiSystem != null && null != fiStateValues) { fiInit.SetValue(null, fiStateValues[1].GetValue(null)); fiSystem.SetValue(null, null); } ConfigSystem confSys = new ConfigSystem(); Type configFactoryType = Type.GetType("System.Configuration.Internal.InternalConfigSettingsFactory, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true); IInternalConfigSettingsFactory configSettingsFactory = (IInternalConfigSettingsFactory)Activator.CreateInstance(configFactoryType, true); configSettingsFactory.SetConfigurationSystem(confSys, false); Type clientConfigSystemType = Type.GetType("System.Configuration.ClientConfigurationSystem, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true); clientConfigSystem = (IInternalConfigSystem)Activator.CreateInstance(clientConfigSystemType, true); }
public void SunnyDay() { FileInfo resFile = TestResourceLoader.ExportResource(this, ".config", new FileInfo(Path.GetTempFileName() + ".config")); string exePath = resFile.FullName.Substring(0, resFile.FullName.Length - ".config".Length); Assert.IsTrue(resFile.Exists); IInternalConfigSystem prevConfig = null; try { ExeConfigurationSystem ccs = new ExeConfigurationSystem(exePath); prevConfig = ConfigurationUtils.SetConfigurationSystem(ccs, true); LogSetting settings = (LogSetting)ConfigurationManager.GetSection("logging"); Assert.AreEqual(typeof(TraceLoggerFactoryAdapter), settings.FactoryAdapterType); Assert.AreEqual("from custom config!", ConfigurationManager.AppSettings["key"]); Assert.IsNull(ConfigurationManager.GetSection("spring/context")); } finally { if (prevConfig != null) { ConfigurationUtils.SetConfigurationSystem(prevConfig, true); } resFile.Delete(); } }
public static void Revert() { if (_originalConfigSystem != null) { _configSections.Clear(); // Revert ConfigurationManager to original state _configSystemField.SetValue(null, _originalConfigSystem); _originalConfigSystem = null; } }
public virtual void SubstituteSystemConfiguration(IConfigurationFactory factory, IList <string> fileNames) { if (OriginalConfiguration != null) { throw new InvalidOperationException("System default configuration already substituted."); } OriginalConfiguration = SubstituteConfigurationSystem(factory, fileNames); }
public virtual void RestoreSystemConfiguration() { if (OriginalConfiguration == null) return; var configManager = new ReflectionAccessor(typeof(ConfigurationManager)); configManager.SetField("s_configSystem", OriginalConfiguration); OriginalConfiguration = null; }
public MoqConfigSystem() { //Ensure the setup of the ConfigurationManager before. var count = ConfigurationManager.AppSettings.Get("asdasd"); if (oldConfigSystem == null) { oldConfigSystem = (IInternalConfigSystem)typeof(ConfigurationManager).GetField("s_configSystem", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null); } }
public virtual void RestoreSystemConfiguration() { if (OriginalConfiguration == null) { return; } var configManager = new ReflectionAccessor(typeof(ConfigurationManager)); configManager.SetField("s_configSystem", OriginalConfiguration); OriginalConfiguration = null; }
// Called by ASP.NET to allow hierarchical configuration settings and ASP.NET specific extenstions. internal static void SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete) { lock (s_initLock) { // It is an error if the configuration system has already been set. if (s_initState != InitState.NotStarted) throw new InvalidOperationException(SR.Config_system_already_set); s_configSystem = configSystem; s_initState = initComplete ? InitState.Completed : InitState.Usable; } }
public override void SubstituteSystemConfiguration(IConfigurationFactory factory, IList <string> fileNames) { if (OriginalConfiguration != null) { throw new InvalidOperationException("Web system default configuration already substituted."); } IInternalConfigSystem originalConfigSystem = SubstituteConfigurationSystem(factory, fileNames); // Web Part (10 level black magic starts here) var httpConfigurationSystem = new ReflectionAccessor(originalConfigSystem.GetType()); // Get original values. var configSystem = httpConfigurationSystem.GetField <IConfigSystem>("s_configSystem"); var replacingSystem = new NConfigSystemReplacement(configSystem, factory, fileNames); // Substitute to decorated instances. httpConfigurationSystem.SetField("s_configSystem", replacingSystem); httpConfigurationSystem.SetField("s_configRoot", replacingSystem.Root); // Refill system cache with new decorated records. var systemWebAss = httpConfigurationSystem.AccessedType.Assembly; var hostingEnviroment = new ReflectionAccessor(systemWebAss.GetType("System.Web.Hosting.HostingEnvironment")); string siteId = hostingEnviroment.GetProperty <string>("SiteID"); string configPath = "dmachine/webroot/" + siteId; var httpRuntime = new ReflectionAccessor(systemWebAss.GetType("System.Web.HttpRuntime")); try { object cacheInternal = httpRuntime.GetProperty("CacheInternal"); var rootReplacement = replacingSystem.Root as NConfigRootReplacement; // In case of single CPU internal caching uses CacheSingle. if (cacheInternal.GetType().Name == "CacheSingle") { UpdateCacheSingle(rootReplacement, cacheInternal, configPath); } else { UpdateCacheMultiple(rootReplacement, configPath, cacheInternal); } } catch (NullReferenceException) { // There is no CacheInternal in .Net 4.7.2 } OriginalConfiguration = originalConfigSystem; }
public static void OverrideSection(string sectionName, ConfigurationSection section) { _configSections[sectionName] = section; if (_originalConfigSystem == null) { // Ensure ConfigurationManager is initialized by reading something from config object o = ConfigurationManager.ConnectionStrings; // Replace config implementation with mock _originalConfigSystem = (IInternalConfigSystem)_configSystemField.GetValue(null); Debug.Assert(_originalConfigSystem != null); _configSystemField.SetValue(null, _mockConfigSystem); } }
// Called by ASP.NET to allow hierarchical configuration settings and ASP.NET specific extenstions. internal static void SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete) { lock (s_initLock) { // It is an error if the configuration system has already been set. if (s_initState != InitState.NotStarted) { throw new InvalidOperationException(SR.Config_system_already_set); } s_configSystem = configSystem; s_initState = initComplete ? InitState.Completed : InitState.Usable; } }
public static void Revert() { if (_originalConfigSystem != null) { _configSections.Clear(); // Revert ConfigurationManager to original state CommonUtil.SetFieldValue(typeof(ConfigurationManager), "s_configSystem", _originalConfigSystem); ResetConfigCache(); _originalConfigSystem = null; } }
internal static void SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete) { lock (s_initLock) { if (s_initState != InitState.NotStarted) { throw new InvalidOperationException(System.Configuration.SR.GetString("Config_system_already_set")); } s_configSystem = configSystem; if (initComplete) { s_initState = InitState.Completed; } else { s_initState = InitState.Usable; } } }
public static void OverrideSection(string sectionName, ConfigurationSection section) { ResetConfigCache(); _configSections[sectionName] = section; if (_originalConfigSystem == null) { // Ensure ConfigurationManager is initialized by reading something from config object o = ConfigurationManager.ConnectionStrings; // Replace config implementation with mock _originalConfigSystem = (IInternalConfigSystem)CommonUtil.GetFieldValue(typeof(ConfigurationManager), "s_configSystem"); Debug.Assert(_originalConfigSystem != null); CommonUtil.SetFieldValue(typeof(ConfigurationManager), "s_configSystem", _mockConfigSystem); } }
/// <summary> /// Re-initializes the ConfigurationManager, allowing us to merge in the settings from Core.Config /// </summary> public static void Activate() { FieldInfo[] fiStateValues = null; Type tInitState = typeof(System.Configuration.ConfigurationManager).GetNestedType("InitState", BindingFlags.NonPublic); if (tInitState != null) { fiStateValues = tInitState.GetFields(); } FieldInfo fiInit = typeof(System.Configuration.ConfigurationManager).GetField("s_initState", BindingFlags.NonPublic | BindingFlags.Static); FieldInfo fiSystem = typeof(System.Configuration.ConfigurationManager).GetField("s_configSystem", BindingFlags.NonPublic | BindingFlags.Static); if (fiInit != null && fiSystem != null && fiStateValues != null) { var state = fiStateValues[1].GetValue(null); fiInit.SetValue(null, state); fiSystem.SetValue(null, null); } ConfigSystemProxy confSys = new ConfigSystemProxy(); Type configFactoryType = Type.GetType("System.Configuration.Internal.InternalConfigSettingsFactory, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true); IInternalConfigSettingsFactory configSettingsFactory = (IInternalConfigSettingsFactory)Activator.CreateInstance(configFactoryType, true); configSettingsFactory.SetConfigurationSystem(confSys, false); Type clientConfigSystemType = Type.GetType("System.Configuration.ClientConfigurationSystem, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true); _clientConfigSystem = (IInternalConfigSystem)Activator.CreateInstance(clientConfigSystemType, true); // Fetch configHost FieldInfo fiClientHost = clientConfigSystemType.GetField("_configHost", BindingFlags.NonPublic | BindingFlags.Instance); _internalConfigClientHost = (IInternalConfigClientHost) fiClientHost?.GetValue(_clientConfigSystem); FieldInfo fiConfigHost = typeof(DelegatingConfigHost).GetField("_host", BindingFlags.NonPublic | BindingFlags.Instance); _internalConfigHost = (IInternalConfigHost)fiConfigHost?.GetValue(_internalConfigClientHost); // Set custom configHost var configHost = new LuxConfigHost(_internalConfigHost); fiConfigHost.SetValue(_internalConfigClientHost, configHost); }
public static void Install(IEnumerable<IConfigurationProvider> providers) { FieldInfo[] fiStateValues = null; Type tInitState = typeof(System.Configuration.ConfigurationManager).GetNestedType("InitState", BindingFlags.NonPublic); if (null != tInitState) { fiStateValues = tInitState.GetFields(); } FieldInfo fiInit = typeof(System.Configuration.ConfigurationManager).GetField("s_initState", BindingFlags.NonPublic | BindingFlags.Static); FieldInfo fiSystem = typeof(System.Configuration.ConfigurationManager).GetField("s_configSystem", BindingFlags.NonPublic | BindingFlags.Static); if (fiInit != null && fiSystem != null && null != fiStateValues) { fiInit.SetValue(null, fiStateValues[1].GetValue(null)); fiSystem.SetValue(null, null); } ConfigurationSystem confSys = new ConfigurationSystem(); Type configFactoryType = Type.GetType("System.Configuration.Internal.InternalConfigSettingsFactory, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true); IInternalConfigSettingsFactory configSettingsFactory = (IInternalConfigSettingsFactory)Activator.CreateInstance(configFactoryType, true); configSettingsFactory.SetConfigurationSystem(confSys, false); Type clientConfigSystemType = Type.GetType("System.Configuration.ClientConfigurationSystem, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true); clientConfigSystem = (IInternalConfigSystem)Activator.CreateInstance(clientConfigSystemType, true); configProviders = providers; if (configProviders != null) { foreach (var p in configProviders) { p.LoadConfigurations(); } } }
public static void SetConfigurationSystem(IInternalConfigSystem configSystem) { Type configurationManagerType = typeof(ConfigurationManager); // this does the magic. calls the internal method // which allows me to inject a provider // why, oh why this is not public? configurationManagerType.InvokeMember( "s_initState", System.Reflection.BindingFlags.SetField | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, configurationManagerType, new object[] { 0 }); configurationManagerType.InvokeMember( "SetConfigurationSystem", System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, configurationManagerType, new object[] { configSystem, true }); }
void IInternalConfigSettingsFactory.SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete) { ConfigurationManager.SetConfigurationSystem(configSystem, initComplete); }
public override void SubstituteSystemConfiguration(IConfigurationFactory factory, IList <string> fileNames) { if (OriginalConfiguration != null) { throw new InvalidOperationException("Web system default configuration already substituted."); } IInternalConfigSystem originalConfigSystem = SubstituteConfigurationSystem(factory, fileNames); // Web Part (10 level black magic starts here) var httpConfigurationSystem = new ReflectionAccessor(originalConfigSystem.GetType()); // Get original values. var configSystem = httpConfigurationSystem.GetField <IConfigSystem>("s_configSystem"); var replacingSystem = new NConfigSystemReplacement(configSystem, factory, fileNames); // Substitute to decorated instances. httpConfigurationSystem.SetField("s_configSystem", replacingSystem); httpConfigurationSystem.SetField("s_configRoot", replacingSystem.Root); // Refill system cache with new decorated records. var systemWebAss = httpConfigurationSystem.AccessedType.Assembly; var hostingEnviroment = new ReflectionAccessor(systemWebAss.GetType("System.Web.Hosting.HostingEnvironment")); string siteId = hostingEnviroment.GetProperty <string>("SiteID"); string configPath = "dmachine/webroot/" + siteId; var httpRuntime = new ReflectionAccessor(systemWebAss.GetType("System.Web.HttpRuntime")); var internalCache = new ReflectionAccessor(httpRuntime.GetProperty("CacheInternal")); var caches = internalCache.GetField("_caches") as IEnumerable ?? Enumerable.Empty <object>(); // Get all site specific configuration records keys for internal cache. var rootReplacement = replacingSystem.Root as NConfigRootReplacement; foreach (var cache in caches) { // Caches stored in array ala hash, so there is could be gaps. if (cache == null) { continue; } var cacheAcessor = new ReflectionAccessor(cache); lock (cacheAcessor.GetField("_lock")) { var entries = cacheAcessor.GetField("_entries") as IEnumerable ?? Enumerable.Empty <object>(); // entries is HashTable, so just iterate through foreach (DictionaryEntry entry in entries) { var keyAccessor = new ReflectionAccessor(entry.Key); // Only configuration cache entries replaced. if (!keyAccessor.GetProperty("Key").ToString().StartsWith(configPath)) { continue; } // Key and Value is the same object in the configuration cache entry. var entryValueAccesor = new ReflectionAccessor(keyAccessor.GetField("_value")); var runtimeConfigAccessor = new ReflectionAccessor(entryValueAccesor.GetField("_runtimeConfig")); IInternalConfigRecord replacingRecord = rootReplacement.CreateConfigRecord(runtimeConfigAccessor.GetField <IInternalConfigRecord>("_configRecord")); runtimeConfigAccessor.SetField("_configRecord", replacingRecord); runtimeConfigAccessor.SetField("_runtimeConfigLKG", null); } } } OriginalConfiguration = originalConfigSystem; }
/// <summary> /// Set the nested configuration system to delegate calls in case we can't resolve a config section ourselves /// </summary> public void SetInnerConfigurationSystem(IInternalConfigSystem innerConfigSystem) { _next = innerConfigSystem; }
/* invoked from System.Web */ internal static IInternalConfigSystem ChangeConfigurationSystem (IInternalConfigSystem newSystem) { if (newSystem == null) throw new ArgumentNullException ("newSystem"); lock (lockobj) { // KLUDGE!! We need that when an assembly loaded inside an ASP.NET // domain does OpenExeConfiguration ("") - we must return the path // to web.config in that instance. /* string t = newSystem.GetType ().ToString (); if (String.Compare (t, "System.Web.Configuration.HttpConfigurationSystem", StringComparison.OrdinalIgnoreCase) == 0) systemWebInUse = true; else systemWebInUse = false; */ IInternalConfigSystem old = configSystem; configSystem = newSystem; return old; } }
public ConfigurationProxy(IInternalConfigSystem originalConfig, string testAssemblyPath) { this._originalConfig = originalConfig; this._testAssemblyPath = testAssemblyPath; }
public NSystemReplacementConfiguration(IInternalConfigSystem originalConfiguration, IConfigurationRepository repository, INSectionMergerRegistry mergerRegistry, IList<string> fileNames) : base(repository, mergerRegistry, fileNames) { this.originalConfiguration = originalConfiguration; }
/// <summary> /// Constructor used by the internal configuration manager /// </summary> /// <param name="baseconf">Native instance of configuration system</param> internal ConfigWcfConfigSystem(IInternalConfigSystem baseconf) { _nativeConfigSystem = baseconf; _svc = WcfClientFactory.Create<IWcfConfigurationService>(CoreConfig.Configuration.WcfUrl); }
public NSystemReplacementConfiguration(IInternalConfigSystem originalConfiguration, IConfigurationRepository repository, INSectionMergerRegistry mergerRegistry, IList <string> fileNames) : base(repository, mergerRegistry, fileNames) { this.originalConfiguration = originalConfiguration; }
public NSystemReplacementConfiguration CreateSystemReplacementConfiguration(IInternalConfigSystem originalConfiguration, IList <string> fileNames) { return(new NSystemReplacementConfiguration(originalConfiguration, ConfigurationRepository, MergerRegistry, fileNames)); }
public NSystemReplacementConfiguration CreateSystemReplacementConfiguration(IInternalConfigSystem originalConfiguration, IList<string> fileNames) { return new NSystemReplacementConfiguration(originalConfiguration, ConfigurationRepository, MergerRegistry, fileNames); }
public ConfigProxy(IInternalConfigSystem baseconf) { this._Baseconf = baseconf; }
/// <summary> /// Constructor used by the internal configuration manager /// </summary> /// <param name="baseconf">Native instance of configuration system</param> internal ConfigWcfConfigSystem(IInternalConfigSystem baseconf) { _nativeConfigSystem = baseconf; _svc = WcfClientFactory.Create <IWcfConfigurationService>(CoreConfig.Configuration.WcfUrl); }
/// <param name="baseconf">IInternalConfigSystem to modify</param> private SecureConfigManager(IInternalConfigSystem baseconf) { _baseconf = baseconf; }
public ConfigurationManagerProxy(IInternalConfigSystem baseconf) { this.baseconf = baseconf; }