private void CreateStorageNode(CacheManagerNode cacheManagerNode, string cacheStorageName) { if (string.IsNullOrEmpty(cacheStorageName)) { return; } CacheStorageData cacheStorageData = cacheManagerSettings.BackingStores.Get(cacheStorageName); if (null == cacheStorageData) { LogError(cacheManagerNode, string.Format(CultureInfo.CurrentUICulture, Resources.ExceptionNoStorageProviderDefined, cacheStorageName)); return; } if (cacheStorageData.Type == typeof(NullBackingStore)) { return; // special case } ConfigurationNode storageNode = NodeCreationService.CreateNodeByDataType(cacheStorageData.GetType(), new object[] { cacheStorageData }); if (null == storageNode) { LogNodeMapError(cacheManagerNode, cacheStorageData.GetType()); return; } cacheManagerNode.AddNode(storageNode); CreateEncryptionNode(storageNode, cacheStorageData.StorageEncryption); }
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); } }
private void CreateFormatterNode(FormatterData formatterData) { FormatterNode formatterNode = NodeCreationService.CreateNodeByDataType(formatterData.GetType(), new object[] { formatterData }) as FormatterNode; if (null == formatterNode) { LogNodeMapError(node, formatterData.GetType()); return; } node.AddNode(formatterNode); }
private void CreateLogFilterNode(LogFilterData logFilterData) { LogFilterNode logFilterNode = NodeCreationService.CreateNodeByDataType(logFilterData.GetType(), new object[] { logFilterData }) as LogFilterNode; if (null == logFilterNode) { LogNodeMapError(node, logFilterData.GetType()); return; } node.AddNode(logFilterNode); }
private void CreateTraceListenerNode(TraceListenerData traceListenerData) { TraceListenerNode traceListenerNode = NodeCreationService.CreateNodeByDataType(traceListenerData.GetType(), new object[] { traceListenerData }) as TraceListenerNode; if (null == traceListenerNode) { LogNodeMapError(node, traceListenerData.GetType()); return; } traceListenerNode.SetFormatter(formatters); node.AddNode(traceListenerNode); }
public void CreateNodeTest() { Type t = typeof(InstrumentationNode); NodeCreationEntry entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples( new AddChildNodeCommand(ServiceProvider, t), t, typeof(InstrumentationConfigurationSection), "Instrumentation"); NodeCreationService.AddNodeCreationEntry(entry); InstrumentationNode node = NodeCreationService.CreateNodeByDataType( typeof(InstrumentationConfigurationSection)) as InstrumentationNode; Assert.IsNotNull(node); }
private void BuildSampleProviderProviders() { foreach (DGTEL.SampleAB.Configuration.SampleProviderData providerData in blockSettings.SampleProviderProviders) { Math providerNode = NodeCreationService.CreateNodeByDataType(providerData.GetType(), new object[] { providerData }) as Math; node.AddNode(providerNode); //if there is a default instance specify it. if (blockSettings.DefaultSampleProviderName == providerData.Name) { node.DefaultDatabase = providerNode; } } }
private void AddInjector(InjectorData injectorData, InjectorCollectionNode injectorsNode) { ConfigurationNode injectorNode = NodeCreationService.CreateNodeByDataType(injectorData.GetType(), new object[] { injectorData }); if (injectorNode == null) { LogNodeMapError(injectorsNode, injectorData.GetType()); } else { injectorsNode.AddNode(injectorNode); } }
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 CreateHashProviderNode(HashProviderCollectionNode hashProviderCollectionNode, HashProviderData hashProviderData) { HashProviderNode hashProviderNode = NodeCreationService.CreateNodeByDataType(hashProviderData.GetType(), new object[] { hashProviderData }) as HashProviderNode; if (null == hashProviderNode) { LogNodeMapError(hashProviderCollectionNode, hashProviderData.GetType()); return; } if (string.Compare(hashProviderNode.Name, cryptographySettings.DefaultHashProviderName) == 0) { defaultHashProviderNode = hashProviderNode; } hashProviderCollectionNode.AddNode(hashProviderNode); }
private void CreateSymmetricCryptoProviderNode(SymmetricCryptoProviderCollectionNode symmetricCryptoProviderCollectionNode, object symmetricCryptoProviderData) { SymmetricCryptoProviderNode symmetricAlgorithmProviderNode = NodeCreationService.CreateNodeByDataType(symmetricCryptoProviderData.GetType(), new object[] { symmetricCryptoProviderData }) as SymmetricCryptoProviderNode; if (null == symmetricAlgorithmProviderNode) { LogNodeMapError(symmetricCryptoProviderCollectionNode, symmetricCryptoProviderData.GetType()); return; } if (string.Compare(symmetricAlgorithmProviderNode.Name, cryptographySettings.DefaultSymmetricCryptoProviderName) == 0) { defaultSymmetricProviderNode = symmetricAlgorithmProviderNode; } symmetricCryptoProviderCollectionNode.AddNode(symmetricAlgorithmProviderNode); }
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); }
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 BuildExceptionHandlerNode(ExceptionTypeNode exceptionTypeNode, ExceptionHandlerData exceptionHandlerData) { ConfigurationNode exceptionHandlerNode = NodeCreationService.CreateNodeByDataType(exceptionHandlerData.GetType(), new object[] { exceptionHandlerData }); exceptionTypeNode.AddNode(exceptionHandlerNode); }