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);
}
