public void ValidateConfigurationSectionFactory() { ConfigurationSection configSection = ConfigurationSectionFactory.GetSection(StorageAccountConfigurationSettings.SectionName); Assert.IsNotNull(configSection, "Config section is null"); Assert.AreEqual <Type>(typeof(StorageAccountConfigurationSettings), configSection.GetType(), "Config section is of a wrong type"); configSection = ConfigurationSectionFactory.GetSection(typeof(RetryPolicyConfigurationSettings).FullName); Assert.IsNotNull(configSection, "Config section is null"); Assert.AreEqual <Type>(typeof(RetryPolicyConfigurationSettings), configSection.GetType(), "Config section is of a wrong type"); configSection = ConfigurationSectionFactory.GetSection(typeof(ApplicationDiagnosticSettings).AssemblyQualifiedName); Assert.IsNotNull(configSection, "Config section is null"); Assert.AreEqual <Type>(typeof(ApplicationDiagnosticSettings), configSection.GetType(), "Config section is of a wrong type"); }
/// <summary> /// Retrieves the specified <see cref="System.Configuration.ConfigurationSection"/> for a given application running of the specified machine. /// </summary> /// <param name="sectionName">The name of the section to be retrieved.</param> /// <param name="applicationName">The name of the application for which a configuration section is being requested.</param> /// <param name="machineName">The name of the machine on which the requesting application is running.</param> /// <returns>The specified <see cref="System.Configuration.ConfigurationSection"/>, or a null reference if a section by that name is not found.</returns> public ConfigurationSection GetSection(string sectionName, string applicationName, string machineName) { var callToken = TraceManager.RulesComponent.TraceIn(sectionName, this.configPolicy, this.configVersion); try { PolicyExecutionInfo policyExecInfo = new PolicyExecutionInfo(PolicyName, PolicyVersion); policyExecInfo.AddParameter(WellKnownContractMember.MessageParameters.SectionName, sectionName); policyExecInfo.AddParameter(WellKnownContractMember.MessageParameters.ApplicationName, applicationName); policyExecInfo.AddParameter(WellKnownContractMember.MessageParameters.MachineName, machineName); ConfigurationSection configSection = ConfigurationSectionFactory.GetSection(sectionName); if (configSection != null) { PolicyExecutionResult execResult = PolicyHelper.Execute(policyExecInfo, RulesEngineFactFactory.GetFacts(configSection)); if (execResult.Success) { // If policy invocation was successful, we need to update the policy version number of reflect the true version of the policy. this.actualConfigVersion = new Version(execResult.PolicyVersion.Major, execResult.PolicyVersion.Minor); if (SourceChanged != null) { SourceChanged(this, new ConfigurationSourceChangedEventArgs(this, new string[] { sectionName })); } return(configSection); } else { throw new ConfigurationErrorsException(String.Format(CultureInfo.CurrentCulture, ExceptionMessages.ConfigPolicyExecutionFailed, execResult.PolicyName), execResult.Errors.Count > 0 ? execResult.Errors[0] : null); } } else { throw new ConfigurationErrorsException(String.Format(CultureInfo.CurrentCulture, ExceptionMessages.ConfigurationSectionNotSupported, sectionName, Resources.RulesEngineConfigurationSourceElementDisplayName)); } } finally { TraceManager.RulesComponent.TraceOut(callToken); } }
private ConfigurationSection RetrieveSection(string sectionName) { var callToken = TraceManager.DebugComponent.TraceIn(sectionName); try { using (ReliableServiceBusClient <IOnPremiseConfigurationServiceChannel> configServiceClient = new ReliableServiceBusClient <IOnPremiseConfigurationServiceChannel>(this.sbEndpointInfo, this.retryPolicy)) { var startScopeInvokeService = TraceManager.DebugComponent.TraceStartScope(Resources.ScopeOnPremiseConfigurationSourceInvokeService, callToken); try { // Invoke the WCF service in a reliable fashion and retrieve the specified configuration section. XmlElement configSectionXml = configServiceClient.RetryPolicy.ExecuteAction <XmlElement>(() => { return(configServiceClient.Client.GetConfigurationSection(sectionName, CloudEnvironment.CurrentRoleName, CloudEnvironment.CurrentRoleMachineName)); }); if (configSectionXml != null) { // Instantiate a configuration object that correspond to the specified section. ConfigurationSection configSection = ConfigurationSectionFactory.GetSection(sectionName); // Gotcha: configuration section deserializer requires a well-formed XML document including processing instruction. XmlDocument configXml = FrameworkUtility.CreateXmlDocument(); configXml.AppendChild(configXml.ImportNode(configSectionXml, true)); // Configure XML reader settings to disable validation and ignore certain XML entities. XmlReaderSettings settings = new XmlReaderSettings { CloseInput = true, IgnoreWhitespace = true, IgnoreComments = true, ValidationType = ValidationType.None, IgnoreProcessingInstructions = true }; // Create a reader to consume the XML data. using (XmlReader reader = XmlReader.Create(new StringReader(configXml.OuterXml), settings)) { // Attempt to cast the configuration section object into SerializableConfigurationSection for further check. SerializableConfigurationSection serializableSection = configSection as SerializableConfigurationSection; // Check if the the configuration section natively supports serialization/de-serialization. if (serializableSection != null) { // Yes, it's supported. Invoke the ReadXml method to consume XML and turn it into object model. serializableSection.ReadXml(reader); } else { // No, it's unsupported. Need to do something different, starting with positioning the XML reader to the first available node. reader.Read(); // Invoke the DeserializeSection method via reflection. This is the only way as the method is internal. MethodInfo info = configSection.GetType().GetMethod(WellKnownContractMember.MethodNames.DeserializeSection, BindingFlags.NonPublic | BindingFlags.Instance); info.Invoke(configSection, new object[] { reader }); } reader.Close(); } if (SourceChanged != null) { SourceChanged(this, new ConfigurationSourceChangedEventArgs(this, new string[] { sectionName })); } return(configSection); } else { // The specified section is not supported by the remote configuration source. We should not throw an exception and rely on the caller to handle an empty section. return(null); } } finally { TraceManager.DebugComponent.TraceEndScope(Resources.ScopeOnPremiseConfigurationSourceInvokeService, startScopeInvokeService, callToken); } } } catch (Exception ex) { TraceManager.DebugComponent.TraceError(ex, callToken); throw; } finally { TraceManager.DebugComponent.TraceOut(callToken); } }