private IEnumerable <TypeRegistration> CreateCryptographyManagerRegistrations(IConfigurationSource configurationSource)
{
var hashProviderNames = (from data in HashProviders select data.Name).ToArray();
var algorithmProviderNames = (from data in SymmetricCryptoProviders select data.Name).ToArray();
var instrumentationSection = InstrumentationConfigurationSection.GetSection(configurationSource);
yield return(new TypeRegistration <IDefaultCryptographyInstrumentationProvider>(
() => new DefaultCryptographyEventLogger(instrumentationSection.PerformanceCountersEnabled,
instrumentationSection.EventLoggingEnabled,
instrumentationSection.ApplicationInstanceName))
{
Lifetime = TypeRegistrationLifetime.Transient,
IsDefault = true
});
yield return(new TypeRegistration <CryptographyManager>(() =>
new CryptographyManagerImpl(
hashProviderNames,
Container.ResolvedEnumerable <IHashProvider>(hashProviderNames),
algorithmProviderNames,
Container.ResolvedEnumerable <ISymmetricCryptoProvider>(algorithmProviderNames),
Container.Resolved <IDefaultCryptographyInstrumentationProvider>()))
{
IsDefault = true,
IsPublicName = true
});
}
public void SetUp()
{
configurationSource = new DictionaryConfigurationSourceWithHandlersQuery();
InstrumentationConfigurationSection instrumentationConfig = new InstrumentationConfigurationSection(true, true, false);
configurationSource.Add(InstrumentationConfigurationSection.SectionName, instrumentationConfig);
settings = new LoggingSettings();
configurationSource.Add(LoggingSettings.SectionName, settings);
settings.SpecialTraceSources.ErrorsTraceSource
= new TraceSourceData("error", SourceLevels.Off);
TraceSourceData traceSourceData = new TraceSourceData("blocking", SourceLevels.All);
traceSourceData.TraceListeners.Add(new TraceListenerReferenceData("listener1"));
settings.TraceSources.Add(traceSourceData);
traceSourceData = new TraceSourceData("nonblocking", SourceLevels.All);
traceSourceData.TraceListeners.Add(new TraceListenerReferenceData("listener2"));
settings.TraceSources.Add(traceSourceData);
TraceListenerData traceListenerData = new CustomTraceListenerData("listener1", typeof(MockBlockingCustomTraceListener), "init 1");
settings.TraceListeners.Add(traceListenerData);
traceListenerData = new MockTraceListenerData("listener2");
settings.TraceListeners.Add(traceListenerData);
reflectionCache = new ConfigurationReflectionCache();
MockTraceListener.Reset();
MockBlockingCustomTraceListener.Reset();
}
void ValidateConfiguration(string configFile)
{
InstrumentationConfigurationSection section = GetSection(configFile);
Assert.IsTrue(section.PerformanceCountersEnabled);
Assert.IsTrue(section.EventLoggingEnabled);
}
public object CreateObject(IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
InstrumentationConfigurationSection objectConfiguration = GetConfiguration(configurationSource);
object createdObject = DoCreateObject((objectConfiguration));
return(createdObject);
}
public void SetUp()
{
provider = new InstrumentationConfigurationSectionManageabilityProvider(new Dictionary <Type, ConfigurationElementManageabilityProvider>(0));
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
section = new InstrumentationConfigurationSection();
}
private TypeRegistration GetDefaultDataEventLoggerRegistration()
{
InstrumentationConfigurationSection instrumentationConfigurationSection = InstrumentationConfigurationSection.GetSection(this.configurationSource);
TypeRegistration <DefaultDataEventLogger> typeRegistration = new TypeRegistration <DefaultDataEventLogger>((Expression <Func <DefaultDataEventLogger> >)(() => new DefaultDataEventLogger(instrumentationConfigurationSection.EventLoggingEnabled)));
typeRegistration.IsDefault = true;
return((TypeRegistration)typeRegistration);
}
public static void GenerateWmiObjects(InstrumentationConfigurationSection configurationObject,
ICollection <ConfigurationSetting> wmiSettings)
{
wmiSettings.Add(new InstrumentationSetting(configurationObject,
configurationObject.EventLoggingEnabled,
configurationObject.PerformanceCountersEnabled,
configurationObject.WmiEnabled));
}
public object CreateObject(IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
InstrumentationConfigurationSection objectConfiguration
= GetConfiguration(configurationSource);
TracerInstrumentationListener createdObject
= new TracerInstrumentationListener(objectConfiguration.PerformanceCountersEnabled);
return(createdObject);
}
public static bool SaveChanges(InstrumentationSetting instrumentationSetting, ConfigurationElement sourceElement)
{
InstrumentationConfigurationSection section = (InstrumentationConfigurationSection)sourceElement;
section.EventLoggingEnabled = instrumentationSetting.EventLoggingEnabled;
section.PerformanceCountersEnabled = instrumentationSetting.PerformanceCountersEnabled;
section.WmiEnabled = instrumentationSetting.WmiEnabled;
return(true);
}
public void then_attributes_with_omitted_values_are_overridden()
{
FileConfigurationSource source = new FileConfigurationSource(TargetFile);
InstrumentationConfigurationSection instrumentationSettings = (InstrumentationConfigurationSection)source.GetSection(InstrumentationConfigurationSection.SectionName);
Assert.AreEqual("Overriden Application", instrumentationSettings.ApplicationInstanceName);
Assert.IsTrue(instrumentationSettings.EventLoggingEnabled);
Assert.IsTrue(instrumentationSettings.PerformanceCountersEnabled);
}
public object CreateObject(IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
InstrumentationConfigurationSection objectConfiguration
= GetConfiguration(configurationSource);
DefaultLoggingEventLogger createdObject
= new DefaultLoggingEventLogger(objectConfiguration.EventLoggingEnabled, objectConfiguration.WmiEnabled);
return(createdObject);
}
public void SetUp()
{
instrumentationSettings = new InstrumentationConfigurationSection(true, true);
loggingSettings = new LoggingSettings();
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(LoggingSettings.SectionName, loggingSettings);
container = new UnityContainer();
}
public void ConstingWithSectionExposesCorrectValues()
{
InstrumentationConfigurationSection section = new InstrumentationConfigurationSection(true, true, true);
InstrumentationNode node = new InstrumentationNode(section);
Assert.IsTrue(node.PerformanceCountersEnabled);
Assert.IsTrue(node.EventLoggingEnabled);
Assert.IsTrue(node.WmiEnabled);
}
protected override void Initialize()
{
LoggingSettings settings = (LoggingSettings)this.ConfigurationSource.GetSection(LoggingSettings.SectionName);
InstrumentationConfigurationSection instrumentationSettings = (InstrumentationConfigurationSection)this.ConfigurationSource.GetSection(InstrumentationConfigurationSection.SectionName);
if (settings == null)
{
return;
}
CreateProvidersPolicies <ILogFormatter, FormatterData>(
Context.Policies,
null,
settings.Formatters,
ConfigurationSource);
CreateProvidersPolicies <ILogFilter, LogFilterData>(
Context.Policies,
null,
settings.LogFilters,
ConfigurationSource);
CreateProvidersPolicies <TraceListener, TraceListenerData>(
Context.Policies,
null,
settings.TraceListeners,
ConfigurationSource);
CreateTraceListenersAdditionalPolicies(
Context.Policies,
Context.Container,
settings.TraceListeners);
CreateTraceSourcesPolicies(
Context.Policies,
settings.TraceSources,
ConfigurationSource);
CreateTraceSourcePolicies(
Context.Policies,
AllTraceSourceKey,
settings.SpecialTraceSources.AllEventsTraceSource,
ConfigurationSource);
CreateTraceSourcePolicies(
Context.Policies,
NoMatchesTraceSourceKey,
settings.SpecialTraceSources.NotProcessedTraceSource,
ConfigurationSource);
CreateTraceSourcePolicies(
Context.Policies,
ErrorsTraceSourceKey,
settings.SpecialTraceSources.ErrorsTraceSource,
ConfigurationSource);
CreateLogWriterPolicies(
Context.Policies,
Context.Container,
settings,
ConfigurationSource);
CreateTraceManagerPolicies(
Context.Policies,
instrumentationSettings);
}
private TypeRegistration GetDefaultDataEventLoggerRegistration()
{
var instrumentationConfigurationSection = InstrumentationConfigurationSection.GetSection(configurationSource);
return(new TypeRegistration <DefaultDataEventLogger>(
() => new DefaultDataEventLogger(instrumentationConfigurationSection.EventLoggingEnabled))
{
IsDefault = true
});
}
private InstrumentationConfigurationSection GetSection(string configFile)
{
ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
fileMap.ExeConfigFilename = configFile;
System.Configuration.Configuration config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
InstrumentationConfigurationSection section = (InstrumentationConfigurationSection)config.GetSection(InstrumentationConfigurationSection.SectionName);
return(section);
}
///<summary>
///</summary>
///<param name="configurationSource"></param>
///<returns></returns>
public static IValidationInstrumentationProvider FromConfigurationSource(IConfigurationSource configurationSource)
{
var instrumentationSection = InstrumentationConfigurationSection.GetSection(configurationSource);
return(new ValidationInstrumentationProvider(
instrumentationSection.PerformanceCountersEnabled,
instrumentationSection.EventLoggingEnabled,
instrumentationSection.ApplicationInstanceName
));
}
private static TypeRegistration GetInstrumentationProviderRegistration(
string instanceName,
IConfigurationSource configurationSource)
{
InstrumentationConfigurationSection instrumentationSection = InstrumentationConfigurationSection.GetSection(configurationSource);
TypeRegistration <IDataInstrumentationProvider> typeRegistration = new TypeRegistration <IDataInstrumentationProvider>((Expression <Func <IDataInstrumentationProvider> >)(() => new NewDataInstrumentationProvider(instanceName, instrumentationSection.PerformanceCountersEnabled, instrumentationSection.EventLoggingEnabled, instrumentationSection.ApplicationInstanceName)));
typeRegistration.Name = instanceName;
return((TypeRegistration)typeRegistration);
}
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);
}
public void CanCreateThroughObjectBuilder()
{
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
InstrumentationConfigurationSection configSection = new InstrumentationConfigurationSection();
configSection.EventLoggingEnabled = true;
configSource.Add(InstrumentationConfigurationSection.SectionName, configSection);
DefaultEventLogger logger = EnterpriseLibraryFactory.BuildUp <DefaultEventLogger>(configSource);
Assert.IsTrue(logger.EventLoggingEnabled);
}
public void SetUp()
{
instrumentationSettings = new InstrumentationConfigurationSection(true, true, false);
loggingSettings = new LoggingSettings();
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(LoggingSettings.SectionName, loggingSettings);
container = new UnityContainer();
container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource));
}
private IEnumerable <TypeRegistration> GetDefaultSecurityEventLoggerRegistrations(IConfigurationSource configurationSource)
{
var instrumentationSection = InstrumentationConfigurationSection.GetSection(configurationSource);
yield return(new TypeRegistration <DefaultSecurityEventLogger>(
() => new DefaultSecurityEventLogger(instrumentationSection.EventLoggingEnabled))
{
Lifetime = TypeRegistrationLifetime.Transient,
IsDefault = true
});
}
private InstrumentationConfigurationSection GetConfigurationSection(IConfigurationSource configurationSource)
{
InstrumentationConfigurationSection section =
(InstrumentationConfigurationSection)configurationSource.GetSection(InstrumentationConfigurationSection.SectionName);
if (section == null)
{
section = new InstrumentationConfigurationSection(false, false, false);
}
return(section);
}
private static TypeRegistration CreateDefaultLoggingEventLoggerRegistration(IConfigurationSource configurationSource)
{
var instrumentationSettings = InstrumentationConfigurationSection.GetSection(configurationSource);
return
(new TypeRegistration <DefaultLoggingEventLogger>(() =>
new DefaultLoggingEventLogger(instrumentationSettings.EventLoggingEnabled))
{
Lifetime = TypeRegistrationLifetime.Transient,
IsDefault = true
});
}
private static void CreateTraceManagerPolicies(IPolicyList policyList,
InstrumentationConfigurationSection instrumentationSettings
)
{
new PolicyBuilder <TraceManager, InstrumentationConfigurationSection>(
null,
instrumentationSettings,
c => new TraceManager(
Resolve.Reference <LogWriter>(null),
new TracerInstrumentationListener(GetPerformanceCountersEnabled(c)))
).AddPoliciesToPolicyList(policyList);
}
/// <summary>
/// Initialize a new instance of the <see cref="InstrumentationNode"/> class with a <see cref="InstrumentationConfigurationSection"/> instance.
/// </summary>
/// <param name="instrumentationSection">A <see cref="InstrumentationConfigurationSection"/> instance.</param>
public InstrumentationNode(InstrumentationConfigurationSection instrumentationSection)
: base(Resources.InstrumentationNodeName)
{
if (null == instrumentationSection)
{
throw new ArgumentNullException("instrumentationSection");
}
this.performanceCountersEnabled = instrumentationSection.PerformanceCountersEnabled;
this.eventLoggingEnabled = instrumentationSection.EventLoggingEnabled;
this.wmiEnabled = instrumentationSection.WmiEnabled;
}
public object[] ToArguments(InstrumentationConfigurationSection configSection)
{
return(instanceName == null
?
new object[] { configSection.PerformanceCountersEnabled, configSection.EventLoggingEnabled, configSection.WmiEnabled, configSection.ApplicationInstanceName }
:
new object[]
{
instanceName, configSection.PerformanceCountersEnabled, configSection.EventLoggingEnabled,
configSection.WmiEnabled, configSection.ApplicationInstanceName
});
}
/// <summary>
/// Return the <see cref="TypeRegistration"/> objects needed to configure
/// the container for the Validation Application Block.
/// </summary>
/// <param name="configurationSource">The <see cref="IConfigurationSource"/> used when creating the <see cref="TypeRegistration{T}"/> entries.</param>
/// <returns>The sequence of <see cref="TypeRegistration"/> objects.</returns>
public IEnumerable <TypeRegistration> GetRegistrations(IConfigurationSource configurationSource)
{
IConfigurationSource availableConfigurationSource = configurationSource ??
ConfigurationSourceFactory.Create();
var instrumentationSection = InstrumentationConfigurationSection.GetSection(configurationSource);
yield return(new TypeRegistration <IValidationInstrumentationProvider>(
() => new ValidationInstrumentationProvider(
instrumentationSection.PerformanceCountersEnabled,
instrumentationSection.EventLoggingEnabled,
instrumentationSection.ApplicationInstanceName))
{
IsDefault = true
});
yield return(new TypeRegistration <AttributeValidatorFactory>(
() => new AttributeValidatorFactory(
Container.Resolved <IValidationInstrumentationProvider>()))
{
IsDefault = true, IsPublicName = true
});
yield return(new TypeRegistration <ConfigurationValidatorFactory>(
() =>
new ConfigurationValidatorFactory(
availableConfigurationSource,
Container.Resolved <IValidationInstrumentationProvider>()))
{
IsDefault = true, IsPublicName = true
});
yield return(new TypeRegistration <ValidationAttributeValidatorFactory>(
() => new ValidationAttributeValidatorFactory(
Container.Resolved <IValidationInstrumentationProvider>()))
{
IsDefault = true, IsPublicName = true
});
yield return(new TypeRegistration <ValidatorFactory>(
() =>
new CompositeValidatorFactory(
Container.Resolved <IValidationInstrumentationProvider>(),
Container.Resolved <AttributeValidatorFactory>(),
Container.Resolved <ConfigurationValidatorFactory>(),
Container.Resolved <ValidationAttributeValidatorFactory>())
)
{
IsDefault = true, IsPublicName = true
});
}
private static TypeRegistration GetInstrumentationProviderRegistration(string instanceName, IConfigurationSource configurationSource)
{
var instrumentationSection = InstrumentationConfigurationSection.GetSection(configurationSource);
return(new TypeRegistration <IDataInstrumentationProvider>(
() => new NewDataInstrumentationProvider(
instanceName,
instrumentationSection.PerformanceCountersEnabled,
instrumentationSection.EventLoggingEnabled,
instrumentationSection.ApplicationInstanceName))
{
Name = instanceName
});
}
private TypeRegistration GetInstrumentationRegistration(IConfigurationSource configurationSource)
{
var instrumentationSection = InstrumentationConfigurationSection.GetSection(configurationSource);
return(new TypeRegistration <IExceptionHandlingInstrumentationProvider>(
() => new ExceptionHandlingInstrumentationProvider(Name,
instrumentationSection.PerformanceCountersEnabled,
instrumentationSection.EventLoggingEnabled,
instrumentationSection.ApplicationInstanceName))
{
Name = Name,
Lifetime = TypeRegistrationLifetime.Transient
});
}
