public async Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action<EndpointConfiguration> configurationBuilderCustomization) { var settings = runDescriptor.Settings; var types = endpointConfiguration.GetTypesScopedByTestClass(); typesToInclude.AddRange(types); var builder = new EndpointConfiguration(endpointConfiguration.EndpointName); builder.TypesToIncludeInScan(typesToInclude); builder.CustomConfigurationSource(configSource); builder.EnableInstallers(); builder.DisableFeature<TimeoutManager>(); builder.Recoverability().Delayed(cfg => cfg.NumberOfRetries(0)); builder.Recoverability().Immediate(cfg => cfg.NumberOfRetries(0)); await builder.DefineTransport(settings, endpointConfiguration.EndpointName).ConfigureAwait(false); builder.DefineBuilder(settings); builder.RegisterComponentsAndInheritanceHierarchy(runDescriptor); Type serializerType; if (settings.TryGet("Serializer", out serializerType)) { builder.UseSerialization((SerializationDefinition) Activator.CreateInstance(serializerType)); } await builder.DefinePersistence(settings, endpointConfiguration.EndpointName).ConfigureAwait(false); builder.GetSettings().SetDefault("ScaleOut.UseSingleBrokerQueue", true); configurationBuilderCustomization(builder); return builder; }
public string MapName(string name, IConfigurationSource configSource) { if (name != null) return name; else return new SecurityConfigurationView(configSource).GetDefaultAuthorizationProviderName(); }
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration, IConfigurationSource configSource) { var settings = runDescriptor.Settings; var types = GetTypesToUse(endpointConfiguration); var transportToUse = settings.GetOrNull("Transport"); SetupLogging(endpointConfiguration); Configure.Features.Enable<Sagas>(); var config = Configure.With(types) .DefineEndpointName(endpointConfiguration.EndpointName) .DefineBuilder(settings.GetOrNull("Builder")) .CustomConfigurationSource(configSource) .DefineSerializer(settings.GetOrNull("Serializer")) .DefineTransport(transportToUse) .InMemorySagaPersister(); if (transportToUse == null || transportToUse.Contains("Msmq") || transportToUse.Contains("SqlServer") || transportToUse.Contains("RabbitMq")) config.UseInMemoryTimeoutPersister(); if (transportToUse == null || transportToUse.Contains("Msmq") || transportToUse.Contains("SqlServer")) config.InMemorySubscriptionStorage(); config.InMemorySagaPersister(); return config.UnicastBus(); }
/// <summary> /// Initializes a new instance of the <see cref="EntLib5Factory"/> class. /// </summary> /// <param name="EntLib5ConfigurationSrc">The enterprise library 5.0 configuration source to load. Supercedes any configuration found in the Config file.</param> public EntLib5Factory(IConfigurationSource EntLib5ConfigurationSrc) { // replace any settings from App.Config with the ones in the provided config source var builder = new ConfigurationSourceBuilder(); builder.UpdateConfigurationWithReplace(EntLib5ConfigurationSrc); EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(EntLib5ConfigurationSrc); }
/// <summary> /// public for unittesting purposes. /// </summary> /// <param name="configurationSource"></param> /// <param name="reconfiguringEventSource"></param> /// <returns></returns> public static IEnumerable<ITypeRegistrationsProvider> CreateTypeRegistrationsProviderLocators(IConfigurationSource configurationSource, IContainerReconfiguringEventSource reconfiguringEventSource) { TypeRegistrationProvidersConfigurationSection section = configurationSource.GetSection(TypeRegistrationProvidersConfigurationSection.SectionName) as TypeRegistrationProvidersConfigurationSection; if (section == null) { section = new TypeRegistrationProvidersConfigurationSection(); } foreach (TypeRegistrationProviderElement typeRegistrationProviderElement in section.TypeRegistrationProviders) { if (!string.IsNullOrEmpty(typeRegistrationProviderElement.SectionName) && !string.IsNullOrEmpty(typeRegistrationProviderElement.ProviderTypeName)) { throw new ConfigurationErrorsException( string.Format("Type Registration Provider Settings '{0}' cannot declare both sectionName and providerType attributes", typeRegistrationProviderElement.Name)); } if (!string.IsNullOrEmpty(typeRegistrationProviderElement.SectionName)) { yield return new ConfigSectionLocator(typeRegistrationProviderElement.SectionName, reconfiguringEventSource); } else if (!string.IsNullOrEmpty(typeRegistrationProviderElement.ProviderTypeName)) { yield return new TypeLoadingLocator(typeRegistrationProviderElement.ProviderTypeName, reconfiguringEventSource); } } }
public void SetUp() { DatabaseDriver.Bootstrap(true); container = DatabaseDriver.ContainerWithDatabase(); source = container.GetInstance<IConfigurationSource>(); }
/// <summary> /// Builds an instance of the concrete subtype of <see cref="T:Microsoft.Practices.EnterpriseLibrary.Data.Database"/> /// the receiver knows how to build, based on the provided connection string and any configuration information /// that might be contained by the <paramref name="configurationSource"/>. /// </summary> /// <param name="name">The name for the new database instance.</param> /// <param name="connectionStringSettings">The connection string for the new database instance.</param> /// <param name="configurationSource">The source for any additional configuration information.</param> /// <returns> /// The new database instance. /// </returns> public Database Assemble(string name, ConnectionStringSettings connectionStringSettings, IConfigurationSource configurationSource) { if(IsDebugEnabled) log.Debug("EnterpriseLibrary용 OracleProvider 인스턴스를 빌드합니다... name=[{0}]", name); var settings = OracleConnectionSettings.GetSettings(configurationSource); if(settings != null) { var data = settings.OracleConnectionsData.Get(name); if(data != null) { var packages = new IOraclePackage[data.Packages.Count]; var num = 0; foreach(var package in data.Packages) { packages[num++] = package; } return new OracleDatabase(connectionStringSettings.ConnectionString); } } if(IsDebugEnabled) log.Debug("OracleDatabase를 생성합니다. connectionString=[{0}]", connectionStringSettings.ConnectionString); return new OracleDatabase(connectionStringSettings.ConnectionString); }
public MessageProcessor(IMessageSource msgSource, IMessageMatcher matcher, ISubscriptionStore store, IConfigurationSource cfg) { LiveMessageSource = msgSource; MessageMatcher = matcher; SubscriptionStore = store; TaskDelay = cfg.Get<int>(this, DefaultDelayKey, DefaultDelay); }
/// <summary> /// Initializes a new instance of the <see cref="ConfigurationSource"/> class. /// </summary> /// <param name="source">The source.</param> public ConfigurationSource(IConfigurationSource source) : base(source) { if (source.Servers != null && source.Servers.Any()) { this.Servers = source.Servers.Select(s => new ServerConfig(s)).ToArray(); } if (source.ServerTypes != null && source.ServerTypes.Any()) { this.ServerTypes = source.ServerTypes.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray(); } if (source.ConnectionFilters != null && source.ConnectionFilters.Any()) { this.ConnectionFilters = source.ConnectionFilters.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray(); } if (source.LogFactories != null && source.LogFactories.Any()) { this.LogFactories = source.LogFactories.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray(); } if (source.ReceiveFilterFactories != null && source.ReceiveFilterFactories.Any()) { this.ReceiveFilterFactories = source.ReceiveFilterFactories.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray(); } if (source.CommandLoaders != null && source.CommandLoaders.Any()) { this.CommandLoaders = source.CommandLoaders.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray(); } }
public Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action<EndpointConfiguration> configurationBuilderCustomization) { var types = GetTypesScopedByTestClass(endpointConfiguration); typesToInclude.AddRange(types); var builder = new EndpointConfiguration(endpointConfiguration.EndpointName); builder.TypesToIncludeInScan(typesToInclude); builder.CustomConfigurationSource(configSource); builder.EnableInstallers(); builder.DisableFeature<TimeoutManager>(); builder.Recoverability() .Delayed(delayed => delayed.NumberOfRetries(0)) .Immediate(immediate => immediate.NumberOfRetries(0)); builder.RegisterComponents(r => { RegisterInheritanceHierarchyOfContextOnContainer(runDescriptor, r); }); builder.UsePersistence<InMemoryPersistence>(); configurationBuilderCustomization(builder); return Task.FromResult(builder); }
protected override void Arrange() { base.Arrange(); Source = new DictionaryConfigurationSource(); ConfigurationSourceBuilder sourceBuilder = new ConfigurationSourceBuilder(); sourceBuilder.ConfigureExceptionHandling() .GivenPolicyWithName("SomePolicy") .ForExceptionType<Exception>() .ReplaceWith<ApplicationException>() .WrapWith<ArgumentException>() .ThenThrowNewException() .ForExceptionType<ArithmeticException>() .LogToCategory("ArithmicExceptions") .ThenDoNothing() .GivenPolicyWithName("Global Policy") .ForExceptionType<Exception>() .ReplaceWith<ApplicationException>() .UsingMessage("replacement message") .WrapWith<Exception>() .ThenNotifyRethrow() .ForExceptionType<InvalidCastException>() .WrapWith<ApplicationException>() .WrapWith<Exception>() .UsingMessage("yes, thats a known bug") .ThenThrowNewException(); sourceBuilder.UpdateConfigurationWithReplace(Source); Section = (ExceptionHandlingSettings)Source.GetSection(ExceptionHandlingSettings.SectionName); }
public object CreateObject(IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { MockTraceListenerClient createdObject = new MockTraceListenerClient(); createdObject.traceListener = TraceListenerCustomFactory.Instance.Create(context, name, configurationSource, reflectionCache); return createdObject; }
/// <summary> /// Consume the set of <see cref="TypeRegistration"/> objects and /// configure the associated container. /// </summary> /// <param name="configurationSource">Configuration source to read registrations from.</param> /// <param name="rootProvider"><see cref="ITypeRegistrationsProvider"/> that knows how to /// read the <paramref name="configurationSource"/> and return all relevant type registrations.</param> public void RegisterAll(IConfigurationSource configurationSource, ITypeRegistrationsProvider rootProvider) { RegisterAllCore(configurationSource, rootProvider); this.configurationSource = configurationSource; configurationSource.SourceChanged += OnConfigurationSourceChanged; }
public string MapName(string name, IConfigurationSource configurationSource) { if (name != null) return name; return new SecurityConfigurationView(configurationSource).GetDefaultSecurityCacheProviderName(); }
private static CachingInstrumentationProvider CreateInstrumentationProvider(string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { CachingInstrumentationProvider instrumentationProvider = new CachingInstrumentationProvider(); new InstrumentationAttachmentStrategy().AttachInstrumentation(name, instrumentationProvider, configurationSource, reflectionCache); return instrumentationProvider; }
public async Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action<EndpointConfiguration> configurationBuilderCustomization) { var settings = runDescriptor.Settings; var types = endpointConfiguration.GetTypesScopedByTestClass(); typesToInclude.AddRange(types); var builder = new EndpointConfiguration(endpointConfiguration.EndpointName); builder.TypesToIncludeInScan(typesToInclude); builder.CustomConfigurationSource(configSource); builder.EnableInstallers(); builder.DisableFeature<TimeoutManager>(); builder.Recoverability() .Delayed(delayed => delayed.NumberOfRetries(0)) .Immediate(immediate => immediate.NumberOfRetries(0)); await builder.DefineTransport(settings, endpointConfiguration.EndpointName).ConfigureAwait(false); builder.RegisterComponentsAndInheritanceHierarchy(runDescriptor); configurationBuilderCustomization(builder); return builder; }
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration, IConfigurationSource configSource) { Configure.ScaleOut(_ => _.UseSingleBrokerQueue()); new Bootstrapper(); //We need this hack here because by default we include all assemblies minus Plugins but for these tests we need to exclude other tests! for (var index = 0; index < Configure.TypesToScan.Count;) { var type = Configure.TypesToScan[index]; if (type.Assembly != Assembly.GetExecutingAssembly()) { index++; continue; } if (!(type.DeclaringType == endpointConfiguration.BuilderType.DeclaringType || type.DeclaringType == endpointConfiguration.BuilderType)) { Configure.TypesToScan.RemoveAt(index); } else { index++; } } LogManager.Configuration = SetupLogging(endpointConfiguration); return Configure.Instance; }
private static ExceptionManager CreateExceptionManager(IConfigurationSource config) { var factory = new ExceptionPolicyFactory(config); var manger = factory.CreateManager(); ExceptionPolicy.SetExceptionManager(manger); return manger; }
/// <summary> /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Returns the default database name from the configuration in the <paramref name="configSource"/>, if the /// value for <paramref name="name"/> is <see langword="null"/> (<b>Nothing</b> in Visual Basic). /// </summary> /// <param name="name">The current name.</param> /// <param name="configSource">The source for configuration information.</param> /// <returns>The default database name if <paramref name="name"/> is <see langword="null"/> (<b>Nothing</b> in Visual Basic), /// otherwise the original value for <b>name</b>.</returns> public string MapName(string name, IConfigurationSource configSource) { if (name != null) return name; return new DatabaseConfigurationView(configSource).DefaultName; }
public void SetUp() { hashProviders = new Dictionary<string, IHashProvider>(); symmetricCrytoProviders = new Dictionary<string, ISymmetricCryptoProvider>(); CreateKeyFile(symmetricKeyFile); CreateKeyFile(keyedHashKeyFile); configSource = ConfigurationSourceFactory.Create(); HashProviderFactory factory = new HashProviderFactory(configSource); defaultHashProvider = factory.Create(hashInstance); hashProviders.Add(hashInstance, defaultHashProvider); SymmetricCryptoProviderFactory symmfactory = new SymmetricCryptoProviderFactory(configSource); defaultSymmetricCryptoProvider = symmfactory.Create(symmInstance); algorithSymmetricCryptoProvider = symmfactory.Create(symmetricAlgorithm1); symmetricCrytoProviders.Add(symmInstance, defaultSymmetricCryptoProvider); symmetricCrytoProviders.Add(symmetricAlgorithm1, algorithSymmetricCryptoProvider); var container = EnterpriseLibraryContainer.CreateDefaultContainer(configSource); cryptographyManager = container.GetInstance<CryptographyManager>(); }
private static LogWriter CreateLogWriter(IConfigurationSource config) { var factory = new LogWriterFactory(config); var writer = factory.Create(); Logger.SetLogWriter(writer); return writer; }
/// <summary> /// Creates the bootstrap. /// </summary> /// <param name="config">The config.</param> /// <returns></returns> public static IBootstrap CreateBootstrap(IConfigurationSource config) { if (config.Isolation == IsolationMode.AppDomain) return new AppDomainBootstrap(config); else return new DefaultBootstrap(config); }
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration, IConfigurationSource configSource) { var settings = runDescriptor.Settings; var types = GetTypesScopedByTestClass(endpointConfiguration); var transportToUse = AcceptanceTest.GetTransportIntegrationFromEnvironmentVar(); SetupLogging(endpointConfiguration); Configure.Features.Enable<Sagas>(); Configure.ScaleOut(_ => _.UseSingleBrokerQueue()); AddMoreConfig(); var config = Configure.With(types) .DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) || IsExternalContract(t)) .DefineEndpointName(endpointConfiguration.EndpointName) .CustomConfigurationSource(configSource) .DefineBuilder(settings.GetOrNull("Builder")); SetSerializer(config); config .DefineTransport(transportToUse) .InMemorySagaPersister() .UseInMemoryTimeoutPersister(); if (transportToUse == null || transportToUse is MsmqTransportIntegration || transportToUse is SqlServerTransportIntegration || transportToUse is AzureStorageQueuesTransportIntegration) { config.InMemorySubscriptionStorage(); } return config.UnicastBus(); }
public void Initialize() { ConfigurationSource = new FileConfigurationSource("typeRegistrationProviderSettings.config", false); TypeRegistrationProvidersSection = Given(ConfigurationSource); }
public override TraceListener Assemble(IBuilderContext context, TraceListenerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { MonitoringDatabaseTraceListenerData castedObjectConfiguration = (MonitoringDatabaseTraceListenerData)objectConfiguration; Database database = (Database) context.HeadOfChain.BuildUp(context, typeof(Database), null, castedObjectConfiguration.ConnectionStringName); ILogFormatter formatter = LogFormatterCustomFactory.Instance.Create(context, castedObjectConfiguration.Formatter, configurationSource, reflectionCache); TraceListener createdObject = new MonitoringDatabaseTraceListener( database, formatter, castedObjectConfiguration.ApplicationName, castedObjectConfiguration.ConnectionStringName); return createdObject; }
public static void InitializeActiveRecord(IConfigurationSource source, params Type[] types) { ActiveRecordStarter.ResetInitializationFlag(); ActiveRecordStarter.Initialize(source); ActiveRecordStarter.RegisterTypes(types); ActiveRecordStarter.CreateSchema(); }
public void FromConfiguration(IConfigurationSource config) { using (var host = new NullHost(config)) { _metaModelRepository = host.Resolver.Resolve(typeof(IMetaModelRepository)) as IMetaModelRepository; } }
/// <summary> /// Consume the set of <see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.TypeRegistration"/> objects and /// configure the associated container. /// </summary> /// <param name="configurationSource">Configuration source to read registrations from.</param> /// <param name="rootProvider"><see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ITypeRegistrationsProvider"/> that knows how to /// read the <paramref name="configurationSource"/> and return all relevant type registrations.</param> public void RegisterAll(IConfigurationSource configurationSource, ITypeRegistrationsProvider rootProvider) { foreach (TypeRegistration registrationEntry in rootProvider.GetRegistrations(configurationSource)) { Register(registrationEntry); } }
/// <summary> /// Creates the <see cref="TypeRegistration"/> entries to use when configuring a container for Exception Handling /// </summary> /// <returns></returns> public IEnumerable<TypeRegistration> GetRegistrations(IConfigurationSource configurationSource) { var registrations = new List<TypeRegistration>(); registrations.AddRange(GetDefaultInstrumentationRegistrations(configurationSource)); foreach (ExceptionPolicyData policyData in ExceptionPolicies) { registrations.AddRange(policyData.GetRegistration(configurationSource)); foreach (var policyTypeData in policyData.ExceptionTypes) { TypeRegistration policyTypeRegistration = policyTypeData.GetRegistration(policyData.Name); registrations.Add(policyTypeRegistration); registrations.AddRange( policyTypeData.ExceptionHandlers.SelectMany(ehd => ehd.GetRegistrations(policyTypeRegistration.Name))); } } TypeRegistration managerRegistration = GetManagerRegistration(ExceptionPolicies.Select(p => p.Name).ToArray()); managerRegistration.IsPublicName = true; registrations.Add(managerRegistration); return registrations; }
public object CreateObject(IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { DatabaseConfigurationView view = new DatabaseConfigurationView(configurationSource); ConnectionStringSettings connectionStringSettings = view.GetConnectionStringSettings(name); DbProviderMapping providerMapping = view.GetProviderMapping(name, connectionStringSettings.ProviderName); return this.GetAssembler(providerMapping.DatabaseType, name, reflectionCache).Assemble(name, connectionStringSettings, configurationSource); }
/// <summary> /// Initializes a new instance of the <see cref="ConfigurationSourceChangedEventArgs"/> class. /// </summary> /// <param name="configurationSource">Configuration source that changed.</param> /// <param name="changedSectionNames">Sequence of the section names in <paramref name="configurationSource"/> /// that have changed.</param> public ConfigurationSourceChangedEventArgs(IConfigurationSource configurationSource, IEnumerable <string> changedSectionNames) { this.configurationSource = configurationSource; this.changedSectionNames = new ReadOnlyCollection <string>(changedSectionNames.ToArray()); }
/// <summary> /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Builds an <see cref="LoggingExceptionHandler"/> based on an instance of <see cref="LoggingExceptionHandlerData"/>. /// </summary> /// <seealso cref="ExceptionHandlerCustomFactory"/> /// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param> /// <param name="objectConfiguration">The configuration object that describes the object to build. Must be an instance of <see cref="LoggingExceptionHandlerData"/>.</param> /// <param name="configurationSource">The source for configuration objects.</param> /// <param name="reflectionCache">The cache to use retrieving reflection information.</param> /// <returns>A fully initialized instance of <see cref="LoggingExceptionHandler"/>.</returns> public IExceptionHandler Assemble(IBuilderContext context, ExceptionHandlerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { LoggingExceptionHandlerData castedObjectConfiguration = (LoggingExceptionHandlerData)objectConfiguration; LogWriter writer = (LogWriter)context.HeadOfChain.BuildUp(context, typeof(LogWriter), null, null); LoggingExceptionHandler createdObject = new LoggingExceptionHandler( castedObjectConfiguration.LogCategory, castedObjectConfiguration.EventId, castedObjectConfiguration.Severity, castedObjectConfiguration.Title, castedObjectConfiguration.Priority, castedObjectConfiguration.FormatterType, writer); return(createdObject); }
public void SetUp() { EnvironmentHelper.AssertOracleClientIsInstalled(); configurationSource = OracleTestConfigurationSource.CreateConfigurationSource(); }
/// <summary> /// Adds the ADM instructions that describe the policies that can be used to override the properties of /// a specific instance of the configuration element type managed by the receiver. /// </summary> /// <param name="contentBuilder">The <see cref="AdmContentBuilder"/> to which the Adm instructions are to be appended.</param> /// <param name="configurationObject">The configuration object instance.</param> /// <param name="configurationSource">The configuration source from where to get additional configuration /// information, if necessary.</param> /// <param name="parentKey">The key path for which the generated instructions' keys must be subKeys of.</param> /// <remarks> /// ADM instructions are generated on a per-instance basis. /// </remarks> protected internal abstract void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder, ConfigurationElement configurationObject, IConfigurationSource configurationSource, String parentKey);
public IFunctionProvider Assemble(IBuilderContext context, FunctionProviderData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { return(new StandardFunctionProvider(objectConfiguration.Name)); }
/// <summary> /// Adds a new configuration source. /// </summary> /// <param name="source">The configuration source to add.</param> /// <returns>The same <see cref="IConfigurationBuilder"/>.</returns> public IConfigurationBuilder Add(IConfigurationSource source !!) {
#pragma warning disable CS0618 public Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action <EndpointConfiguration> configurationBuilderCustomization) #pragma warning restore CS0618 { var types = endpointConfiguration.GetTypesScopedByTestClass().ToList(); types.AddRange(ExtraTypesToInclude()); var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName); configuration.TypesToIncludeInScan(types); configuration.CustomConfigurationSource(configSource); configuration.EnableInstallers(); var transportConfig = configuration.UseTransport <MsmqTransport>(); var routingConfig = transportConfig.Routing(); foreach (var publisher in endpointConfiguration.PublisherMetadata.Publishers) { foreach (var eventType in publisher.Events) { routingConfig.RegisterPublisher(eventType, publisher.PublisherName); } } ApplyConfig(configuration); var queueBindings = configuration.GetSettings().Get <QueueBindings>(); runDescriptor.OnTestCompleted(_ => DeleteQueues(queueBindings)); configuration.RegisterComponentsAndInheritanceHierarchy(runDescriptor); configuration.UsePersistence <InMemoryPersistence>(); configuration.GetSettings().SetDefault("ScaleOut.UseSingleBrokerQueue", true); configurationBuilderCustomization(configuration); return(Task.FromResult(configuration)); }
public SectionInSubordinateSource(ConfigurationSourceHandler configurationSourceHandler, string sectionName, string subordinateSourceName, IConfigurationSource subordinateSource) { this.sectionName = sectionName; this.subordinateSourceName = subordinateSourceName; this.configurationSourceHandler = configurationSourceHandler; Refresh(subordinateSource); }
public SubordinateSource(ConfigurationSourceHandler compositeConfigurationSource, string subordinateSourceName, IConfigurationSource subordinateSource) : this(compositeConfigurationSource, subordinateSourceName, subordinateSource, false) { }
/// <summary> /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Builds a <see cref="WrapHandler"/> based on an instance of <see cref="WrapHandlerData"/>. /// </summary> /// <seealso cref="ExceptionHandlerCustomFactory"/> /// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param> /// <param name="objectConfiguration">The configuration object that describes the object to build. Must be an instance of <see cref="WrapHandlerData"/>.</param> /// <param name="configurationSource">The source for configuration objects.</param> /// <param name="reflectionCache">The cache to use retrieving reflection information.</param> /// <returns>A fully initialized instance of <see cref="WrapHandler"/>.</returns> public IExceptionHandler Assemble(IBuilderContext context, ExceptionHandlerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { WrapHandlerData castedObjectConfiguration = (WrapHandlerData)objectConfiguration; string exceptionMessage = castedObjectConfiguration.ExceptionMessage; if (!string.IsNullOrEmpty(castedObjectConfiguration.ExceptionMessageResourceName)) { Type exceptionMessageResourceType = Type.GetType(castedObjectConfiguration.ExceptionMessageResourceType, false); if (null != exceptionMessageResourceType) { exceptionMessage = ResourceStringLoader.LoadString(exceptionMessageResourceType.FullName, castedObjectConfiguration.ExceptionMessageResourceName, exceptionMessageResourceType.Assembly); } } WrapHandler createdObject = new WrapHandler(exceptionMessage, castedObjectConfiguration.WrapExceptionType); return(createdObject); }
/// <summary> /// Adds a subordinate <see cref="IConfigurationSource"/> to the <see cref="ConfigurationSourceHandler"/>. /// This <see cref="IConfigurationSource"/> will not be refreshed or disposed. /// </summary> /// <param name="sourceName">The name under which the <see cref="IConfigurationSource"/> will be added.</param> /// <param name="configurationSource">The <see cref="IConfigurationSource"/> that will be added.</param> protected void AddCustomSubordinateSource(string sourceName, IConfigurationSource configurationSource) { SubordinateSource sourceHolder = new SubordinateSource(this, sourceName, configurationSource, true); subordinateSourcesByName.Add(sourceName, sourceHolder); }
public SubordinateSource(ConfigurationSourceHandler compositeConfigurationSource, string subordinateSourceName, IConfigurationSource subordinateSource, bool customSource) { this.subordinateSourceName = subordinateSourceName; this.subordinateConfigurationSource = subordinateSource; this.compositeConfigurationSource = compositeConfigurationSource; this.customSource = customSource; this.subordinateConfigurationSource.SourceChanged += new EventHandler <ConfigurationSourceChangedEventArgs>(compositeConfigurationSource_ConfigurationSourceChanged); }
protected override void Arrange() { MergedSource = new FileConfigurationSource(@"MergedConfigurationFile.config"); }
/// <summary> /// Creates a new instance of <see cref="ConfigurationSourceHandler"/> passing the <see cref="IConfigurationSource"/> implementation /// That contains the <see cref="ConfigurationSourceSection"/> configuration. /// </summary> /// <param name="configurationSource">The <see cref="IConfigurationSource"/> implementation that should be extended.</param> protected ConfigurationSourceHandler(IConfigurationSource configurationSource) { this.configurationSource = configurationSource; }
/// <summary> /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Returns a new instance of a concrete subtype of <typeparamref name="TObject"/>, described by the matching configuration object /// of a concrete subtype of <typeparamref name="TConfiguration"/> in <paramref name="objectConfiguration"/>. /// </summary> /// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param> /// <param name="objectConfiguration">The configuration object that describes the object to build.</param> /// <param name="configurationSource">The source for configuration objects.</param> /// <param name="reflectionCache">The cache to use retrieving reflection information.</param> /// <returns>A new instance of the appropriate subtype of <typeparamref name="Tobject"/>.</returns> public virtual TObject Create(IBuilderContext context, TConfiguration objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { IAssembler <TObject, TConfiguration> assembler = GetAssembler(objectConfiguration); TObject createdObject = assembler.Assemble(context, objectConfiguration, configurationSource, reflectionCache); return(createdObject); }
private static TraceListener GetListener(string name, IConfigurationSource configurationSource) { var container = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource); return(container.GetInstance <TraceListener>(name)); }
public IndividualQueueConfigurationSource(IConfigurationSource innerSource) { this.innerSource = innerSource; }
/// <summary> /// IQ# Magic that enables executing the Katas on Jupyter. /// </summary> public KataMagic(IOperationResolver resolver, ISnippets snippets, ILogger <KataMagic> logger, IConfigurationSource configurationSource) { this.Name = $"%kata"; this.Documentation = new Documentation { Summary = "Executes a single test.", Description = "Executes a single test, and reports whether the test passed successfully.", Examples = new [] { "To run a test called `Test`:\n" + "```\n" + "In []: %kata T101_StateFlip_Test \n", " ...: operation StateFlip (q : Qubit) : Unit is Adj + Ctl {\n", " // The Pauli X gate will change the |0⟩ state to the |1⟩ state and vice versa.\n", " // Type X(q);\n", " // Then run the cell using Ctrl/⌘+Enter.\n", "\n", " // ...\n", " }\n" + "Out[]: Qubit in invalid state. Expecting: Zero\n" + " \tExpected:\t0\n" + " \tActual:\t0.5000000000000002\n" + " Try again!" + "```\n" } }; this.Kind = SymbolKind.Magic; this.Execute = this.Run; this.ConfigurationSource = configurationSource; this.Resolver = resolver; this.Snippets = snippets; this.Logger = logger; this.AllAnswers = new Dictionary <OperationInfo, OperationInfo>(); }
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder, TestConfigurationElement configurationObject, IConfigurationSource configurationSource, string elementPolicyKeyName) { throw new Exception("The method or operation is not implemented."); }
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration, IConfigurationSource configSource) { var settings = runDescriptor.Settings; SetupLogging(endpointConfiguration); var types = GetTypesToUse(endpointConfiguration); var transportToUse = settings.GetOrNull("Transport"); Configure.Features.Enable <Features.Sagas>(); SettingsHolder.SetDefault("ScaleOut.UseSingleBrokerQueue", true); var config = Configure.With(types) .DefineEndpointName(endpointConfiguration.EndpointName) .CustomConfigurationSource(configSource) .DefineBuilder(settings.GetOrNull("Builder")) .DefineSerializer(settings.GetOrNull("Serializer")) .DefineTransport(settings) .DefineSagaPersister(settings.GetOrNull("SagaPersister")); if (transportToUse == null || transportToUse.Contains("Msmq") || transportToUse.Contains("SqlServer") || transportToUse.Contains("RabbitMq")) { config.UseInMemoryTimeoutPersister(); } if (transportToUse == null || transportToUse.Contains("Msmq") || transportToUse.Contains("SqlServer")) { config.DefineSubscriptionStorage(settings.GetOrNull("SubscriptionStorage")); } return(config.UnicastBus()); }
public IElementActionProvider Assemble(IBuilderContext context, ElementActionProviderData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { return (IElementActionProvider)Activator.CreateInstance(objectConfiguration.Type); }
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder, TestConfigurationElement configurationObject, IConfigurationSource configurationSource, string elementPolicyKeyName) { }
private static ILogFilter GetFilter(string name, IConfigurationSource configurationSource) { var settings = LoggingSettings.GetLoggingSettings(configurationSource); return(settings.LogFilters.Get(name).BuildFilter()); }
/// <summary> /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code. /// Builds a <see cref="BinaryLogFormatter"/> based on an instance of <see cref="BinaryLogFormatterData"/>. /// </summary> /// <seealso cref="LogFormatterCustomFactory"/> /// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param> /// <param name="objectConfiguration">The configuration object that describes the object to build. Must be an instance of <see cref="BinaryLogFormatterData"/>.</param> /// <param name="configurationSource">The source for configuration objects.</param> /// <param name="reflectionCache">The cache to use retrieving reflection information.</param> /// <returns>A fully initialized instance of <see cref="BinaryLogFormatter"/>.</returns> public ILogFormatter Assemble(IBuilderContext context, FormatterData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { return(new BinaryLogFormatter()); }
public static LogWriter CreateLogWriterFromConfigFile( string configFileName) { if (!string.IsNullOrWhiteSpace(configFileName)) { if (Path.IsPathRooted(configFileName)) { _logConfigurationFileName = configFileName; } else { var data = AppDomain .CurrentDomain .GetData("APP_CONFIG_FILE"); Debug.Assert(data != null); var path = Path.GetDirectoryName(data.ToString()); configFileName = Path.Combine(path, configFileName); _logConfigurationFileName = !string.IsNullOrWhiteSpace(configFileName) && File.Exists(configFileName) ? configFileName : null; } } try { // if the file name is null or empty or does not exists - go for the app.config var logConfigSource = _logConfigurationFileName == null ? (IConfigurationSource) new SystemConfigurationSource() : (IConfigurationSource) new FileConfigurationSource(_logConfigurationFileName); var logger = new LogWriterFactory(logConfigSource).Create(); if (_logConfiguration != null) { _logConfiguration.SourceChanged -= (o, e) => Facility.FacilitiesRegistrar.RefreshLogger( CreateLogWriterFromConfigFile(_logConfigurationFileName)); _logConfiguration.Dispose(); } _logConfiguration = logConfigSource; _logConfiguration.SourceChanged += (o, e) => Facility.FacilitiesRegistrar.RefreshLogger( CreateLogWriterFromConfigFile(_logConfigurationFileName)); return(logger); } catch (Exception x) { if (_logConfiguration != null) { _logConfiguration.Dispose(); } // wrap and throw throw new ConfigurationErrorsException( string.Format( "There was an error loading the configuration from {0}.", string.IsNullOrWhiteSpace(configFileName) ? "the system configuration file" : configFileName), x); } }
/// <inheritdoc /> public IConfigurationBuilder Add(IConfigurationSource source) { return(_builder.Add(source)); }
private static TraceListener GetListener(string name, IConfigurationSource configurationSource) { var settings = LoggingSettings.GetLoggingSettings(configurationSource); return(settings.TraceListeners.Get(name).BuildTraceListener(settings)); }
public IConfigurationBuilder Add(IConfigurationSource source) { Sources.Add(source); return(this); }
/// <summary> /// Initializes a new instance of the <see cref="ConfigurationObjectPolicy"/> class with a configuration source. /// </summary> /// <param name="configurationSource">The configuration source.</param> public ConfigurationObjectPolicy(IConfigurationSource configurationSource) { this.configurationSource = configurationSource; }
public Startup(IConfigurationSource configurationSource) { this.configurationSource = configurationSource; }