private void AddValidatorNodes(ConfigurationNode parentNode, ValidatorDataCollection validatorCollection) { foreach (ValidatorData validator in validatorCollection) { ConfigurationNode validatorNode = NodeCreationService.CreateNodeByDataType(validator.GetType(), new object[] { validator }); if (validatorNode == null) { LogNodeMapError(parentNode, validator.GetType()); continue; } if (validator is OrCompositeValidatorData) { ValidatorDataCollection childValidators = ((OrCompositeValidatorData)validator).Validators; AddValidatorNodes(validatorNode, childValidators); } else if (validator is AndCompositeValidatorData) { ValidatorDataCollection childValidators = ((AndCompositeValidatorData)validator).Validators; AddValidatorNodes(validatorNode, childValidators); } parentNode.AddNode(validatorNode); } }
public void SavesMergedConfiguration() { File.SetAttributes(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, FileAttributes.Normal); ApplicationNode.Hierarchy.Load(); Assert.AreEqual(0, ServiceHelper.GetErrorService(ServiceProvider).ConfigurationErrorCount); ApplicationNode.Hierarchy.Open(); Assert.AreEqual(0, ServiceHelper.GetErrorService(ServiceProvider).ConfigurationErrorCount); InstrumentationNode instrumentationNode = (InstrumentationNode)ApplicationNode.Hierarchy.FindNodeByType(typeof(InstrumentationNode)); // test the settings from the original configuration file Assert.IsNotNull(instrumentationNode); Assert.IsTrue(instrumentationNode.EventLoggingEnabled); Assert.IsFalse(instrumentationNode.PerformanceCountersEnabled); Assert.IsTrue(instrumentationNode.WmiEnabled); // load the environment override ConfigurationNode overridesNode = ApplicationNode.Hierarchy.FindNodeByType(typeof(EnvironmentalOverridesNode)); Assert.IsNotNull(overridesNode); EnvironmentNode overrideNode = new EnvironmentNodeBuilder(ServiceProvider).Build("Environment.dconfig", overridesNode.Hierarchy); overridesNode.AddNode(overrideNode); // run the save merged environment command SaveMergedEnvironmentCommand command = new SaveMergedEnvironmentCommand(ServiceProvider); command.Execute(overrideNode); Assert.IsTrue(command.MergeSucceeded); // load the resulting configuration ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap(); fileMap.ExeConfigFilename = Path.Combine( Path.GetDirectoryName(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile), overrideNode.EnvironmentConfigurationFile); System.Configuration.Configuration configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); // get the instrumentation node InstrumentationConfigurationSection instrumentationSection = (InstrumentationConfigurationSection)configuration.GetSection(InstrumentationConfigurationSection.SectionName); // test the settings from the merged configuration file Assert.IsNotNull(instrumentationSection); Assert.IsFalse(instrumentationSection.EventLoggingEnabled); Assert.IsTrue(instrumentationSection.PerformanceCountersEnabled); Assert.IsTrue(instrumentationSection.WmiEnabled); }
private void BuildSecurityCacheProviders(SecurityCacheProviderData securityProviderData) { ConfigurationNode securityProviderNode = NodeCreationService.CreateNodeByDataType(securityProviderData.GetType(), new object[] { securityProviderData }); if (null == securityProviderNode) { LogNodeMapError(securityCacheProviderCollectionNode_, securityProviderData.GetType()); return; } if (securityProviderNode.Name == settings.DefaultSecurityCacheProviderName) { defaultSecurityCacheProviderNode = (SecurityCacheProviderNode)securityProviderNode; } securityCacheProviderCollectionNode_.AddNode(securityProviderNode); }
private void AddTraceListeners(ConfigurationNode node, TraceSourceData data) { foreach (TraceListenerReferenceData refData in data.TraceListeners) { TraceListenerReferenceNode referenceNode = new TraceListenerReferenceNode(refData); foreach (TraceListenerNode listenerNode in listeners.Nodes) { if (listenerNode.Name == referenceNode.Name) { referenceNode.ReferencedTraceListener = listenerNode; } } node.AddNode(referenceNode); } }
/// <summary> /// Adds either a <see cref="FieldNode"/>, <see cref="MethodNode"/> or <see cref="PropertyNode"/> to the current <see cref="RuleSetNode"/>, /// based on the selected member. /// </summary> /// <param name="node">The parent node to newly added configuration node.</param> protected override void ExecuteCore(ConfigurationNode node) { try { UIService.BeginUpdate(); Type type = FindType(node); if (type != null) { IUIService uiService = ServiceHelper.GetUIService(serviceProvider); TypeMemberChooser memberChooser = new TypeMemberChooser(uiService); foreach (MemberInfo memberInfo in memberChooser.ChooseMembers(type)) { if (memberInfo != null) { if (node.Nodes.Contains(memberInfo.Name)) { continue; } ConfigurationNode childNode = null; if (memberInfo is PropertyInfo) { childNode = new PropertyNode(memberInfo.Name); } else if (memberInfo is MethodInfo) { childNode = new MethodNode(memberInfo.Name); } else if (memberInfo is FieldInfo) { childNode = new FieldNode(memberInfo.Name); } else { Debug.Assert(false, "memberInfo should be either PropertyInfo, MethodInfo or FieldInfo"); } node.AddNode(childNode); UIService.SetUIDirty(node.Hierarchy); } } } } finally { UIService.EndUpdate(); } }
public void MergingOverridesRemovesTheConfigurationSourcesSection() { ApplicationNode.Hierarchy.Load(); Assert.AreEqual(0, ServiceHelper.GetErrorService(ServiceProvider).ConfigurationErrorCount); ApplicationNode.Hierarchy.Open(); Assert.AreEqual(0, ServiceHelper.GetErrorService(ServiceProvider).ConfigurationErrorCount); ConfigurationNode configurationSourceSectionNode = ApplicationNode.Hierarchy.FindNodeByType(typeof(ConfigurationSourceSectionNode)); Assert.IsNotNull(configurationSourceSectionNode); // load the environment override ConfigurationNode overridesNode = ApplicationNode.Hierarchy.FindNodeByType(typeof(EnvironmentalOverridesNode)); Assert.IsNotNull(overridesNode); EnvironmentNode overrideNode = new EnvironmentNodeBuilder(ServiceProvider).Build("Environment.dconfig", overridesNode.Hierarchy); overridesNode.AddNode(overrideNode); // run the save merged environment command SaveMergedEnvironmentCommand command = new SaveMergedEnvironmentCommand(ServiceProvider); command.Execute(overrideNode); Assert.IsTrue(command.MergeSucceeded); // load the resulting configuration ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap(); fileMap.ExeConfigFilename = Path.Combine( Path.GetDirectoryName(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile), overrideNode.EnvironmentConfigurationFile); System.Configuration.Configuration configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); // get the instrumentation node ConfigurationSection configurationSourceSection = configuration.GetSection(ConfigurationSourceSection.SectionName); Assert.IsNull(configurationSourceSection); }
/// <summary> /// <para>Creates an instance of the child node class and adds it as a child of the parent node. The node will be a <see cref="HashAlgorithmProviderNode"/>.</para> /// </summary> /// <param name="node"> /// <para>The parent node to add the newly created <see cref="AddChildNodeCommand.ChildNode"/>.</para> /// </param> protected override void ExecuteCore(ConfigurationNode node) { INodeNameCreationService service = ServiceHelper.GetNameCreationService(ServiceProvider); Debug.Assert(service != null, "Could not find the INodeNameCreationService"); TypeSelectorUI selector = new TypeSelectorUI( typeof(SHA1Managed), typeof(HashAlgorithm), TypeSelectorIncludes.None ); DialogResult typeResult = selector.ShowDialog(); if (typeResult == DialogResult.OK) { Type selectedAlgorithmType = selector.SelectedType; if (selector.SelectedType.IsSubclassOf(typeof(KeyedHashAlgorithm))) { CryptographicKeyWizard keyWizard = new CryptographicKeyWizard(new KeyedHashAlgorithmKeyCreator(selector.SelectedType)); DialogResult keyResult = keyWizard.ShowDialog(); if (keyResult == DialogResult.OK) { KeyedHashAlgorithmProviderNode providerNode = new KeyedHashAlgorithmProviderNode(); providerNode.Key = keyWizard.KeySettings; providerNode.AlgorithmType = selector.SelectedType; node.AddNode(providerNode); providerNode.Name = service.GetUniqueName(selector.SelectedType.Name, providerNode, providerNode.Parent); } } else { base.ExecuteCore(node); HashAlgorithmProviderNode providerNode = (HashAlgorithmProviderNode)ChildNode; providerNode.AlgorithmType = selectedAlgorithmType; providerNode.Name = service.GetUniqueName(selector.SelectedType.Name, providerNode, providerNode.Parent); } } }
private void BuildAuthorizationProviders(AuthorizationProviderData authorizationProviderData) { ConfigurationNode authorizationProviderNode = NodeCreationService.CreateNodeByDataType(authorizationProviderData.GetType(), new object[] { authorizationProviderData }); if (null == authorizationProviderNode) { LogNodeMapError(authorizationProviderCollectionNode_, authorizationProviderData.GetType()); return; } if (typeof(AuthorizationRuleProviderData) == authorizationProviderData.GetType()) { AuthorizationRuleProviderData authorizationRuleProviderData = (AuthorizationRuleProviderData)authorizationProviderData; this.authorizationRuleProviderNode = (AuthorizationRuleProviderNode)authorizationProviderNode; authorizationRuleProviderData.Rules.ForEach(new Action <AuthorizationRuleData>(BuildAuthorizationRule)); } if (authorizationProviderNode.Name == settings.DefaultAuthorizationProviderName) { defaultAuthorizationNode = (AuthorizationProviderNode)authorizationProviderNode; } authorizationProviderCollectionNode_.AddNode(authorizationProviderNode); }
public override void Register(IServiceProvider serviceProvider) { new EnvironmentalOverridesCommandRegistrar(serviceProvider).Register(); if (serviceProvider.GetService(typeof(IEnvironmentMergeService)) == null) { IServiceContainer serviceContainer = (IServiceContainer)serviceProvider.GetService(typeof(IServiceContainer)); EnvironmentMergeAware environmentMergeService = new EnvironmentMergeAware(); serviceContainer.AddService(typeof(IEnvironmentMergeService), environmentMergeService); serviceContainer.AddService(typeof(EnvironmentMergeAware), environmentMergeService); } ConfigurationNode rootNode = ServiceHelper.GetCurrentRootNode(serviceProvider); if (rootNode != null) { if (rootNode.Nodes[Resources.EnvironmentalOverridesNodeName] == null) { rootNode.AddNode(new EnvironmentalOverridesNode()); } } }
protected override void ExecuteCore(ConfigurationNode node) { IUIService uiService = ServiceHelper.GetUIService(ServiceProvider); using (OpenFileDialog fileDialog = new OpenFileDialog()) { fileDialog.Filter = Resources.EnvironmentDeltaFileDialogFilter; fileDialog.CheckFileExists = true; fileDialog.CheckPathExists = true; fileDialog.AddExtension = true; fileDialog.DefaultExt = Resources.DefaultEnvironmentDeltaFileExtension; fileDialog.RestoreDirectory = true; if (DialogResult.OK == uiService.ShowOpenDialog(fileDialog)) { uiService.BeginUpdate(); try { EnvironmentNodeBuilder nodeBuilder = new EnvironmentNodeBuilder(ServiceProvider); EnvironmentNode childNode = nodeBuilder.Build(fileDialog.FileName, node.Hierarchy); node.AddNode(childNode); uiService.SetUIDirty(node.Hierarchy); uiService.ActivateNode(childNode); } catch (Exception e) { uiService.ShowError(e, Resources.ErrorOpeningEnvironmentMergeFile); } finally { uiService.EndUpdate(); } } } }
private void CreateEncryptionNode(ConfigurationNode storageNode, string storageEncryption) { if (string.IsNullOrEmpty(storageEncryption)) { return; } StorageEncryptionProviderData encryptionProviderData = cacheManagerSettings.EncryptionProviders.Get(storageEncryption); if (null == encryptionProviderData) { LogError(storageNode, string.Format(CultureInfo.CurrentUICulture, Resources.ExceptionNoEncrypitonProviderDefined, storageEncryption)); return; } ConfigurationNode encyrptionNode = NodeCreationService.CreateNodeByDataType(encryptionProviderData.GetType(), new object[] { encryptionProviderData }); if (null == encyrptionNode) { LogNodeMapError(storageNode, encryptionProviderData.GetType()); return; } storageNode.AddNode(encyrptionNode); }
private void BuildAuthorizationRule(AuthorizationRuleData authorizationRule) { AuthorizationRuleNode ruleNode = new AuthorizationRuleNode(authorizationRule); authorizationRuleProviderNode.AddNode(ruleNode); }