Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

610 lines
26 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="HealthMonitoringSectionHelper.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Configuration {
using System;
using System.Xml;
using System.Configuration;
using System.Collections.Specialized;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text;
using System.ComponentModel;
using System.Web.Hosting;
using System.Web.Util;
using System.Web.Configuration;
using System.Web.Management;
using System.Web.Compilation;
using System.Security.Permissions;
internal class HealthMonitoringSectionHelper {
static HealthMonitoringSectionHelper s_helper;
static RuleInfoComparer s_ruleInfoComparer = new RuleInfoComparer();
HealthMonitoringSection _section;
internal ProviderInstances _providerInstances;
internal Hashtable _customEvaluatorInstances;
internal ArrayList _ruleInfos;
bool _enabled;
// Cached matched rules for system events. For details, see comments for s_eventArrayDimensionSizes
// in WebEventCodes.cs
static ArrayList[,] _cachedMatchedRules;
#if DBG
// Because we assume no two different event type will use the same event code, in debug mode
// we use this hashtable to make sure our assumption is true.
Hashtable _cachedTypeOfMatchedRulesSystem = new Hashtable();
#endif
// Cached matched rules based on WebBaseEvent Hashcode, and is for non-system events.
Hashtable _cachedMatchedRulesForCustomEvents;
static internal HealthMonitoringSectionHelper GetHelper() {
if (s_helper == null) {
s_helper = new HealthMonitoringSectionHelper();
}
return s_helper;
}
HealthMonitoringSectionHelper() {
// Handle config exceptions so we can still log messages to the event log.
try {
_section = RuntimeConfig.GetAppConfig().HealthMonitoring;
}
catch(Exception e) {
// If InitializationException has not already been set, then this exception
// is happening because the <healthMonitoring> section has an error.
// By setting InitializationException, we allow the exception to be displayed in the response.
// If InitializationException is already set, ignore this exception so we can
// display the original in the response.
if (HttpRuntime.InitializationException == null) {
HttpRuntime.InitializationException = e;
}
_section = RuntimeConfig.GetAppLKGConfig().HealthMonitoring;
// WOS 1965670: if we fail to get the section throw the previous error
if (_section == null) {
throw;
}
}
_enabled = _section.Enabled;
if (!_enabled) {
return;
}
// First run some basic sanity check
BasicSanityCheck();
// Init some class members
_ruleInfos = new ArrayList();
_customEvaluatorInstances = new Hashtable();
_providerInstances = new ProviderInstances(_section);
_cachedMatchedRulesForCustomEvents = new Hashtable(new WebBaseEventKeyComparer());
_cachedMatchedRules = new ArrayList[WebEventCodes.GetEventArrayDimensionSize(0),
WebEventCodes.GetEventArrayDimensionSize(1)];
BuildRuleInfos();
_providerInstances.CleanupUninitProviders();
}
internal bool Enabled {
get { return _enabled; }
}
internal HealthMonitoringSection HealthMonitoringSection {
get { return _section; }
}
[FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
void BasicSanityCheck() {
Type type;
foreach (ProviderSettings providerSettings in _section.Providers) {
// Make sure the type is valid.
type = ConfigUtil.GetType(providerSettings.Type, "type", providerSettings);
// Make sure the type support WebEventProvider
HandlerBase.CheckAssignableType(providerSettings.ElementInformation.Properties["type"].Source,
providerSettings.ElementInformation.Properties["type"].LineNumber,
typeof(WebEventProvider), type);
}
foreach (EventMappingSettings eventMappingSettings in _section.EventMappings) {
// Make sure the type is valid.
type = ConfigUtil.GetType(eventMappingSettings.Type, "type", eventMappingSettings);
// Make sure startEventCode <= endEventCode
if (!(eventMappingSettings.StartEventCode <= eventMappingSettings.EndEventCode)) {
string attribute;
// We don't know which one was specified unless we test it
attribute = "startEventCode";
if (eventMappingSettings.ElementInformation.Properties[attribute].LineNumber == 0) {
attribute = "endEventCode";
Debug.Assert(eventMappingSettings.ElementInformation.Properties[attribute].LineNumber != 0,
"eventMappingSettings.ElementInformation.Properties[attribute].LineNumber != 0");
}
throw new ConfigurationErrorsException(
SR.GetString(SR.Event_name_invalid_code_range),
eventMappingSettings.ElementInformation.Properties[attribute].Source, eventMappingSettings.ElementInformation.Properties[attribute].LineNumber);
}
// Make sure the type support WebBaseEvent
HandlerBase.CheckAssignableType(eventMappingSettings.ElementInformation.Properties["type"].Source,
eventMappingSettings.ElementInformation.Properties["type"].LineNumber,
typeof(System.Web.Management.WebBaseEvent), type);
// It's a valid type. Might as well save it.
eventMappingSettings.RealType = type;
}
foreach (RuleSettings rule in _section.Rules) {
// Go thru all the Rules, and make sure all referenced provider, eventName
// and profile exist.
string provider = rule.Provider;
if (!String.IsNullOrEmpty(provider)) {
ProviderSettings providerSettings = _section.Providers[provider];
if (providerSettings == null) {
throw new ConfigurationErrorsException(
SR.GetString(SR.Health_mon_provider_not_found, provider),
rule.ElementInformation.Properties["provider"].Source,
rule.ElementInformation.Properties["provider"].LineNumber);
}
}
string profile = rule.Profile;
if (!String.IsNullOrEmpty(profile)) {
if (_section.Profiles[profile] == null) {
throw new ConfigurationErrorsException(
SR.GetString(SR.Health_mon_profile_not_found, profile),
rule.ElementInformation.Properties["profile"].Source,
rule.ElementInformation.Properties["profile"].LineNumber);
}
}
if (_section.EventMappings[rule.EventName] == null) {
throw new ConfigurationErrorsException(
SR.GetString(SR.Event_name_not_found, rule.EventName),
rule.ElementInformation.Properties["eventName"].Source, rule.ElementInformation.Properties["eventName"].LineNumber);
}
}
}
void DisplayRuleInfo(RuleInfo ruleInfo) {
#if DEBUG
Debug.Trace("BuildRuleInfos", "====================== Rule Info =======================");
Debug.Trace("BuildRuleInfos", "name:" + ruleInfo._ruleSettings.Name);
Debug.Trace("BuildRuleInfos", "type:" + ruleInfo._eventMappingSettings.RealType.Name);
Debug.Trace("BuildRuleInfos", "minInstances:" + ruleInfo._minInstances);
Debug.Trace("BuildRuleInfos", "maxLimit:" + ruleInfo._maxLimit);
Debug.Trace("BuildRuleInfos", "minInterval:" + ruleInfo._minInterval);
Debug.Trace("BuildRuleInfos", "provider:" + ruleInfo._ruleSettings.Provider);
Debug.Trace("BuildRuleInfos", "referenced provider:" + (ruleInfo._referencedProvider == null ? String.Empty : ruleInfo._referencedProvider.GetType().Name));
Debug.Trace("BuildRuleInfos", "=========================================================");
#endif
}
void BuildRuleInfos() {
Debug.Trace("BuildRuleInfos", "BuildRuleInfos called");
// Each ruleInfo is an object that takes the information
// stored in a ruleSettings and merge it with values from profileSettings.
// At the end, we'll sort the rules based on type (most specific type last)
foreach (RuleSettings ruleSettings in _section.Rules) {
RuleInfo ruleInfo = CreateRuleInfo(ruleSettings);
DisplayRuleInfo(ruleInfo);
_ruleInfos.Add(ruleInfo);
}
_ruleInfos.Sort(s_ruleInfoComparer);
}
RuleInfo CreateRuleInfo(RuleSettings ruleSettings) {
RuleInfo ruleInfo = new RuleInfo(ruleSettings, _section);
// Inherit values from profile
MergeValuesWithProfile(ruleInfo);
// Find out which provider it's referencing
InitReferencedProvider(ruleInfo);
// Initialize the cutom evaluator type
InitCustomEvaluator(ruleInfo);
return ruleInfo;
}
void InitReferencedProvider(RuleInfo ruleInfo) {
String providerName;
WebEventProvider provider;
Debug.Assert(ruleInfo._referencedProvider == null, "ruleInfo._referencedProvider == null");
providerName = ruleInfo._ruleSettings.Provider;
if (String.IsNullOrEmpty(providerName)) {
return;
}
provider = _providerInstances[providerName];
Debug.Assert(provider != null, "provider != null");
ruleInfo._referencedProvider = provider;
}
void MergeValuesWithProfile(RuleInfo ruleInfo) {
ProfileSettings profileSettings = null;
if (ruleInfo._ruleSettings.ElementInformation.Properties["profile"].ValueOrigin != PropertyValueOrigin.Default) {
profileSettings = _section.Profiles[ruleInfo._ruleSettings.Profile];
Debug.Assert(profileSettings != null, "profileSettings != null");
}
if (profileSettings != null && ruleInfo._ruleSettings.ElementInformation.Properties["minInstances"].ValueOrigin == PropertyValueOrigin.Default) {
ruleInfo._minInstances = profileSettings.MinInstances;
}
else {
ruleInfo._minInstances = ruleInfo._ruleSettings.MinInstances;
}
if (profileSettings != null && ruleInfo._ruleSettings.ElementInformation.Properties["maxLimit"].ValueOrigin == PropertyValueOrigin.Default) {
ruleInfo._maxLimit = profileSettings.MaxLimit;
}
else {
ruleInfo._maxLimit = ruleInfo._ruleSettings.MaxLimit;
}
if (profileSettings != null && ruleInfo._ruleSettings.ElementInformation.Properties["minInterval"].ValueOrigin == PropertyValueOrigin.Default) {
ruleInfo._minInterval = profileSettings.MinInterval;
}
else {
ruleInfo._minInterval = ruleInfo._ruleSettings.MinInterval;
}
if (profileSettings != null && ruleInfo._ruleSettings.ElementInformation.Properties["custom"].ValueOrigin == PropertyValueOrigin.Default) {
ruleInfo._customEvaluator = profileSettings.Custom;
ruleInfo._customEvaluatorConfig = profileSettings;
}
else {
ruleInfo._customEvaluator = ruleInfo._ruleSettings.Custom;
ruleInfo._customEvaluatorConfig = ruleInfo._ruleSettings;
}
}
void InitCustomEvaluator(RuleInfo ruleInfo) {
string customEvaluator = ruleInfo._customEvaluator;
if (customEvaluator == null ||
customEvaluator.Trim().Length == 0) {
ruleInfo._customEvaluatorType = null;
return;
}
ruleInfo._customEvaluatorType = ConfigUtil.GetType(ruleInfo._customEvaluator,
"custom", ruleInfo._customEvaluatorConfig);
// Make sure the type support WebBaseEvent
HandlerBase.CheckAssignableType(ruleInfo._customEvaluatorConfig.ElementInformation.Properties["custom"].Source,
ruleInfo._customEvaluatorConfig.ElementInformation.Properties["custom"].LineNumber,
typeof(System.Web.Management.IWebEventCustomEvaluator), ruleInfo._customEvaluatorType);
// Create a public instance of the custom evaluator
if (_customEvaluatorInstances[ruleInfo._customEvaluatorType] == null) {
_customEvaluatorInstances[ruleInfo._customEvaluatorType] = HttpRuntime.CreatePublicInstance(ruleInfo._customEvaluatorType);
}
}
// Find the corresponding array of RuleInfo based on the fired event
internal ArrayList FindFiringRuleInfos(Type eventType, int eventCode) {
ArrayList foundFiringRuleInfos;
bool systemEvent = eventCode < WebEventCodes.WebExtendedBase;
CustomWebEventKey customWebEventKey = null;
object lockObject;
int index0 = 0, index1 = 0;
#if DBG
if (systemEvent) {
Type type;
type = (Type)_cachedTypeOfMatchedRulesSystem[eventCode];
if (type == null) {
lock(_cachedTypeOfMatchedRulesSystem) {
type = (Type)_cachedTypeOfMatchedRulesSystem[eventCode];
if (type == null) {
_cachedTypeOfMatchedRulesSystem[eventCode] = eventType;
}
}
}
if (type != null) {
Debug.Assert(type == eventType,
"For system events, we assume each event code will map only to one event type. " +
"Eventcode= " + eventCode + "; stored type= " + type.ToString() +
"; raised event type= " + eventType);
}
}
#endif
// First, we look at the cache to see if we find the array.
if (systemEvent) {
WebEventCodes.GetEventArrayIndexsFromEventCode(eventCode, out index0, out index1);
foundFiringRuleInfos = _cachedMatchedRules[index0, index1];
}
else {
customWebEventKey = new CustomWebEventKey(eventType, eventCode);
foundFiringRuleInfos = (ArrayList)_cachedMatchedRulesForCustomEvents[customWebEventKey];
}
if (foundFiringRuleInfos != null) {
return foundFiringRuleInfos;
}
if (systemEvent) {
lockObject = _cachedMatchedRules;
}
else {
lockObject = _cachedMatchedRulesForCustomEvents;
}
lock (lockObject) {
if (systemEvent) {
foundFiringRuleInfos = _cachedMatchedRules[index0, index1];
}
else {
Debug.Assert(customWebEventKey != null);
foundFiringRuleInfos = (ArrayList)_cachedMatchedRulesForCustomEvents[customWebEventKey];
}
if (foundFiringRuleInfos != null) {
return foundFiringRuleInfos;
}
// Not found in cache.
ArrayList matchedRules = new ArrayList();
// Go thru the sorted ruleInfo array and look for matching ruleInfo,
// starting from the most specific type.
for (int i = _ruleInfos.Count - 1; i >= 0; i--) {
RuleInfo curRule = (RuleInfo)_ruleInfos[i];
// Now see if the current rule matches the raised event
if (curRule.Match(eventType, eventCode)) {
matchedRules.Add(new FiringRuleInfo(curRule));
}
}
// Then for each matched rule, we need to figure out if the provider it
// uses is also used by other rules. We need this info because if multiple rules are
// using the same provider, we fire the event to the provider only once.
int count = matchedRules.Count;
for (int i = 0; i < count; i++) {
FiringRuleInfo info1 = (FiringRuleInfo)matchedRules[i];
if (info1._ruleInfo._referencedProvider != null) {
for (int j = i + 1; j < count; j++) {
FiringRuleInfo info2 = (FiringRuleInfo)matchedRules[j];
if (info2._ruleInfo._referencedProvider != null && // ignore null-provider
info2._indexOfFirstRuleInfoWithSameProvider == -1 && // ignore rules that were marked already
info1._ruleInfo._referencedProvider == info2._ruleInfo._referencedProvider) { // they are pointing to the same provider
// We'll remember the index of the first rule info that share the same
// provider. For details on how this index is used, please see
// WebBaseEvent.RaiseInternal.
if (info1._indexOfFirstRuleInfoWithSameProvider == -1) {
info1._indexOfFirstRuleInfoWithSameProvider = i;
}
info2._indexOfFirstRuleInfoWithSameProvider = i;
}
}
}
}
#if DBG
Debug.Trace("FindRuleInfos", "------------------------------------------------");
Debug.Trace("FindRuleInfos", "Find ruleInfos for event with type=" + eventType.ToString() +
", EventCode=" + eventCode);
foreach(FiringRuleInfo info in matchedRules) {
Debug.Trace("FindRuleInfos", "Provider=" + info._ruleInfo._ruleSettings.Provider +
"; eventNameType=" + info._ruleInfo._eventMappingSettings.RealType.ToString() +
"; _indexOfFirstRuleInfoWithSameProvider=" + info._indexOfFirstRuleInfoWithSameProvider);
}
Debug.Trace("FindRuleInfos", "------------------------------------------------");
#endif
// save matchedRules in the cache
if (systemEvent) {
_cachedMatchedRules[index0, index1] = matchedRules;
}
else {
Debug.Assert(customWebEventKey != null);
_cachedMatchedRulesForCustomEvents[customWebEventKey] = matchedRules;
}
return matchedRules;
}
}
internal class RuleInfo {
internal string _customEvaluator;
internal ConfigurationElement _customEvaluatorConfig;
// The following properties are cached here for performance reason
internal int _minInstances;
internal int _maxLimit;
internal TimeSpan _minInterval; // in seconds
internal RuleSettings _ruleSettings;
internal WebEventProvider _referencedProvider;
internal Type _customEvaluatorType;
internal EventMappingSettings _eventMappingSettings;
internal RuleFiringRecord _ruleFiringRecord;
internal RuleInfo(RuleSettings ruleSettings, HealthMonitoringSection section) {
_eventMappingSettings = section.EventMappings[ruleSettings.EventName];
_ruleSettings = ruleSettings;
_ruleFiringRecord = new RuleFiringRecord(this);
}
internal bool Match(Type eventType, int eventCode) {
// Fail if the type doesn't match.
if (!(eventType.Equals(_eventMappingSettings.RealType) ||
eventType.IsSubclassOf(_eventMappingSettings.RealType))) {
return false;
}
// Fail if the event code doesn't match
if (!(_eventMappingSettings.StartEventCode <= eventCode &&
eventCode <= _eventMappingSettings.EndEventCode)) {
return false;
}
return true;
}
}
internal class FiringRuleInfo {
internal RuleInfo _ruleInfo;
internal int _indexOfFirstRuleInfoWithSameProvider;
internal FiringRuleInfo(RuleInfo ruleInfo) {
_ruleInfo = ruleInfo;
_indexOfFirstRuleInfoWithSameProvider = -1;
}
}
internal class ProviderInstances {
internal Hashtable _instances; // case-insensitive because the providers collection is too.
[PermissionSet(SecurityAction.Assert, Unrestricted = true)]
internal ProviderInstances(HealthMonitoringSection section) {
// Build the array of providers
// Don't create an instance yet, but only store the providerInfo in the HashTable.
_instances = CollectionsUtil.CreateCaseInsensitiveHashtable(section.Providers.Count);
foreach (object obj in section.Providers) {
ProviderSettings settings = (ProviderSettings)obj;
// Please note we are storing the ProviderSettings in the hashtable.
// But if we create an instance of that provider, we will replace
// that string with a provider object.
_instances.Add(settings.Name, settings);
}
}
WebEventProvider GetProviderInstance(string providerName) {
WebEventProvider provider;
object o;
o = _instances[providerName];
if (o == null) {
return null;
}
ProviderSettings providerSettings = o as ProviderSettings;
if (providerSettings != null) {
// If what we got is still a ProviderSettings, it means we haven't created an instance
// of it yet.
Type type;
string typeName = providerSettings.Type;
type = BuildManager.GetType(typeName, false);
Debug.Assert(type != null, "type != null");
if (typeof(IInternalWebEventProvider).IsAssignableFrom(type)) {
provider = (WebEventProvider)HttpRuntime.CreateNonPublicInstance(type);
}
else {
provider = (WebEventProvider)HttpRuntime.CreatePublicInstance(type);
}
using (new ProcessImpersonationContext()) {
try {
provider.Initialize(providerSettings.Name, providerSettings.Parameters);
}
catch (ConfigurationErrorsException) {
throw;
}
catch (ConfigurationException e) {
throw new ConfigurationErrorsException(e.Message, providerSettings.ElementInformation.Properties["type"].Source,
providerSettings.ElementInformation.Properties["type"].LineNumber);
}
catch {
throw;
}
}
Debug.Trace("ProviderInstances", "Create a provider instance: " +
"name=" + providerSettings.Name + ";type=" + typeName);
_instances[providerName] = provider;
}
else {
provider = o as WebEventProvider;
Debug.Assert(provider != null, "provider != null");
}
return provider;
}
internal WebEventProvider this[String name] {
get {
return GetProviderInstance(name);
}
}
// Cleanup each provider for which we have NOT created an instance.
internal void CleanupUninitProviders() {
ArrayList list = new ArrayList();
foreach (DictionaryEntry de in _instances) {
if (de.Value is ProviderSettings) {
list.Add(de.Key);
}
}
foreach (object o in list) {
Debug.Trace("ProviderInstances", "Remove " + (string)o + " from providers");
_instances.Remove(o);
}
}
internal bool ContainsKey(string name) {
return _instances.ContainsKey(name);
}
public IDictionaryEnumerator GetEnumerator() {
return _instances.GetEnumerator();
}
}
}
}