public Engine() { _timerTracker = new TimerTracker(); _nodeCreationService = new NodeCreationService(_timerTracker); _calculator = new StatisticsCalculator(); _CSVWriteService = new CSVWriteService(); }
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); } }
public override void SetUp() { base.SetUp(); Type nodeType = typeof(CustomAuthenticationProviderNode); NodeCreationEntry entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, nodeType), nodeType, typeof(CustomAuthenticationProviderData), SR.CustomAuthenticationProviderCommandName); NodeCreationService.AddNodeCreationEntry(entry); nodeType = typeof(CustomRolesProviderNode); entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, nodeType), nodeType, typeof(CustomRolesProviderData), SR.CustomRolesProviderCommandName); NodeCreationService.AddNodeCreationEntry(entry); nodeType = typeof(CustomAuthorizationProviderNode); entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, nodeType), nodeType, typeof(CustomAuthorizationProviderData), SR.CustomAuthorizationProviderCommandName); NodeCreationService.AddNodeCreationEntry(entry); nodeType = typeof(CustomProfileProviderNode); entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, nodeType), nodeType, typeof(CustomProfileProviderData), SR.CustomProfileProviderCommandName); NodeCreationService.AddNodeCreationEntry(entry); nodeType = typeof(CustomSecurityCacheProviderNode); entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, nodeType), nodeType, typeof(CustomSecurityCacheProviderData), SR.CustomSecurityCacheNodeCommandName); NodeCreationService.AddNodeCreationEntry(entry); nodeType = typeof(AuthorizationRuleProviderNode); entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, nodeType), nodeType, typeof(AuthorizationRuleProviderData), SR.AuthorizationRuleProviderCommandName); NodeCreationService.AddNodeCreationEntry(entry); }
public void MakeSureCanCreateAuthorizationRuleNodeFromAuthorizationRuleProviderData() { SecurityConfigurationDesignManager manager = new SecurityConfigurationDesignManager(); manager.Register(Host); ConfigurationNode node = NodeCreationService.CreateNode(typeof(AuthorizationRuleProviderData)); Assert.IsNotNull(node); }
public override void SetUp() { base.SetUp(); XmlIncludeTypeService.AddXmlIncludeType(section, typeof(MyConfigurationData)); Type nodeType = typeof(MyConfigurationNode); NodeCreationEntry entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, nodeType), nodeType, typeof(MyConfigurationData), "My Configuraiton Node"); NodeCreationService.AddNodeCreationEntry(entry); }
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 CanGetANodeWithNotADirectInheritanceChain() { string name = "Foo"; Type nodeType = typeof(MyDerivedNode); NodeCreationEntry entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, nodeType), nodeType, typeof(MyDerivedData), name); NodeCreationService.AddNodeCreationEntry(entry); StringCollection names = NodeCreationService.GetDisplayNames(typeof(StorageProviderNode)); Assert.IsTrue(names.Contains(name)); }
public void RegisterTest() { CachingDatabaseConfigurationDesignManager manager = new CachingDatabaseConfigurationDesignManager(); ApplicationData data = ApplicationData.FromCurrentAppDomain(); ApplicationConfigurationNode node = new ApplicationConfigurationNode(data); CreateHierarchyAndAddToHierarchyService(node, CreateDefaultConfiguration()); manager.Register(Host); DataCacheStorageNode testNode = NodeCreationService.CreateNode(typeof(DataCacheStorageData), new object[] { new DataCacheStorageData() }) as DataCacheStorageNode; Assert.IsNotNull(testNode); }
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); } }
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); }
public void CreateNodeTest() { Type t = typeof(XmlFileStorageProviderNode); NodeCreationEntry entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, t), t, typeof(XmlFileStorageProviderData), SR.XmlFileStorageProviderNodeTypeNameDescription); NodeCreationService.AddNodeCreationEntry(entry); t = typeof(XmlSerializerTransformerNode); entry = NodeCreationEntry.CreateNodeCreationEntryNoMultiples(new AddChildNodeCommand(Host, t), t, typeof(XmlSerializerTransformerData), SR.XmlSerializerTransformerNodeFriendlyName); NodeCreationService.AddNodeCreationEntry(entry); XmlFileStorageProviderNode node = NodeCreationService.CreateNode(typeof(XmlFileStorageProviderData)) as XmlFileStorageProviderNode; Assert.IsNotNull(node); }
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 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 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 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); }
public void Setup() { service = new NodeCreationService(); }