Files
mono/mcs/class/referencesource/System.Web/HttpApplicationFactory.cs
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

699 lines
28 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="HttpApplicationFactory.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
/*
* The HttpApplicationFactory class
*
* Copyright (c) 1999 Microsoft Corporation
*/
namespace System.Web {
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using System.Web.Caching;
using System.Web.Compilation;
using System.Web.Hosting;
using System.Web.Management;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.Util;
/*
* Application Factory only has and public static methods to get / recycle
* application instances. The information cached per application
* config file is encapsulated by ApplicationData class.
* Only one static instance of application factory is created.
*/
internal class HttpApplicationFactory {
internal const string applicationFileName = "global.asax";
// the only instance of application factory
private static HttpApplicationFactory _theApplicationFactory = new HttpApplicationFactory();
// flag to indicate that initialization was done
private bool _inited;
// filename for the global.asax
private String _appFilename;
private ICollection _fileDependencies;
// call application on_start only once
private bool _appOnStartCalled = false;
// call application on_end only once
private bool _appOnEndCalled = false;
// dictionary of application state
private HttpApplicationState _state;
// class of the application object
private Type _theApplicationType;
// free list of app objects
private Stack _freeList = new Stack();
private int _numFreeAppInstances = 0;
private int _minFreeAppInstances = 0;
// free list of special (context-less) app objects
// to be used for global events (App_OnEnd, Session_OnEnd, etc.)
private Stack _specialFreeList = new Stack();
private int _numFreeSpecialAppInstances = 0;
private const int _maxFreeSpecialAppInstances = 20;
// results of the reflection on the app class
private MethodInfo _onStartMethod; // Application_OnStart
private int _onStartParamCount;
private MethodInfo _onEndMethod; // Application_OnEnd
private int _onEndParamCount;
private MethodInfo _sessionOnEndMethod; // Session_OnEnd
private int _sessionOnEndParamCount;
private EventHandler _sessionOnEndEventHandlerAspCompatHelper; // helper for AspCompat
// list of methods suspected as event handlers
private MethodInfo[] _eventHandlerMethods;
internal HttpApplicationFactory() {
_sessionOnEndEventHandlerAspCompatHelper = new EventHandler(this.SessionOnEndEventHandlerAspCompatHelper);
}
internal static void ThrowIfApplicationOnStartCalled() {
if (_theApplicationFactory._appOnStartCalled) {
throw new InvalidOperationException(SR.GetString(SR.MethodCannotBeCalledAfterAppStart));
}
}
//
// Initialization on first request
//
private void Init() {
if (_customApplication != null)
return;
try {
try {
_appFilename = GetApplicationFile();
CompileApplication();
}
finally {
// Always set up global.asax file change notification, even if compilation
// failed. This way, if the problem is fixed, the appdomain will be restarted.
SetupChangesMonitor();
}
}
catch { // Protect against exception filters
throw;
}
}
internal static void SetupFileChangeNotifications() {
// Just call EnsureInited() to make sure global.asax FCN are set up.
// But don't if we never even got to initialize Fusion
if (HttpRuntime.CodegenDirInternal != null)
_theApplicationFactory.EnsureInited();
}
private void EnsureInited() {
if (!_inited) {
lock (this) {
if (!_inited) {
Init();
_inited = true;
}
}
}
}
internal static void EnsureAppStartCalledForIntegratedMode(HttpContext context, HttpApplication app) {
if (!_theApplicationFactory._appOnStartCalled) {
Exception error = null;
lock (_theApplicationFactory) {
if (!_theApplicationFactory._appOnStartCalled) {
using (new DisposableHttpContextWrapper(context)) {
// impersonation could be required (UNC share or app credentials)
WebBaseEvent.RaiseSystemEvent(_theApplicationFactory, WebEventCodes.ApplicationStart);
if (_theApplicationFactory._onStartMethod != null) {
app.ProcessSpecialRequest(context,
_theApplicationFactory._onStartMethod,
_theApplicationFactory._onStartParamCount,
_theApplicationFactory,
EventArgs.Empty,
null);
}
}
}
_theApplicationFactory._appOnStartCalled = true;
error = context.Error;
}
if (error != null) {
throw new HttpException(error.Message, error);
}
}
}
private void EnsureAppStartCalled(HttpContext context) {
if (!_appOnStartCalled) {
lock (this) {
if (!_appOnStartCalled) {
using (new DisposableHttpContextWrapper(context)) {
// impersonation could be required (UNC share or app credentials)
WebBaseEvent.RaiseSystemEvent(this, WebEventCodes.ApplicationStart);
// fire outside of impersonation as HttpApplication logic takes
// care of impersonation by itself
FireApplicationOnStart(context);
}
_appOnStartCalled = true;
}
}
}
}
internal static String GetApplicationFile() {
return Path.Combine(HttpRuntime.AppDomainAppPathInternal, applicationFileName);
}
private void CompileApplication() {
// Get the Application Type and AppState from the global file
_theApplicationType = BuildManager.GetGlobalAsaxType();
BuildResultCompiledGlobalAsaxType result = BuildManager.GetGlobalAsaxBuildResult();
if (result != null) {
// Even if global.asax was already compiled, we need to get the collections
// of application and session objects, since they are not persisted when
// global.asax is compiled. Ideally, they would be, but since <object> tags
// are only there for ASP compat, it's not worth the trouble.
// Note that we only do this is the rare case where we know global.asax contains
// <object> tags, to avoid always paying the price (VSWhidbey 453101)
if (result.HasAppOrSessionObjects) {
GetAppStateByParsingGlobalAsax();
}
// Remember file dependencies
_fileDependencies = result.VirtualPathDependencies;
}
if (_state == null) {
_state = new HttpApplicationState();
}
// Prepare to hookup event handlers via reflection
ReflectOnApplicationType();
}
private void GetAppStateByParsingGlobalAsax() {
using (new ApplicationImpersonationContext()) {
// It may not exist if the app is precompiled
if (FileUtil.FileExists(_appFilename)) {
ApplicationFileParser parser;
parser = new ApplicationFileParser();
AssemblySet referencedAssemblies = System.Web.UI.Util.GetReferencedAssemblies(
_theApplicationType.Assembly);
referencedAssemblies.Add(typeof(string).Assembly);
VirtualPath virtualPath = HttpRuntime.AppDomainAppVirtualPathObject.SimpleCombine(
applicationFileName);
parser.Parse(referencedAssemblies, virtualPath);
// Create app state
_state = new HttpApplicationState(parser.ApplicationObjects, parser.SessionObjects);
}
}
}
private bool ReflectOnMethodInfoIfItLooksLikeEventHandler(MethodInfo m) {
if (m.ReturnType != typeof(void))
return false;
// has to have either no args or two args (object, eventargs)
ParameterInfo[] parameters = m.GetParameters();
switch (parameters.Length) {
case 0:
// ok
break;
case 2:
// param 0 must be object
if (parameters[0].ParameterType != typeof(System.Object))
return false;
// param 1 must be eventargs
if (parameters[1].ParameterType != typeof(System.EventArgs) &&
!parameters[1].ParameterType.IsSubclassOf(typeof(System.EventArgs)))
return false;
// ok
break;
default:
return false;
}
// check the name (has to have _ not as first or last char)
String name = m.Name;
int j = name.IndexOf('_');
if (j <= 0 || j > name.Length-1)
return false;
// special pseudo-events
if (StringUtil.EqualsIgnoreCase(name, "Application_OnStart") ||
StringUtil.EqualsIgnoreCase(name, "Application_Start")) {
_onStartMethod = m;
_onStartParamCount = parameters.Length;
}
else if (StringUtil.EqualsIgnoreCase(name, "Application_OnEnd") ||
StringUtil.EqualsIgnoreCase(name, "Application_End")) {
_onEndMethod = m;
_onEndParamCount = parameters.Length;
}
else if (StringUtil.EqualsIgnoreCase(name, "Session_OnEnd") ||
StringUtil.EqualsIgnoreCase(name, "Session_End")) {
_sessionOnEndMethod = m;
_sessionOnEndParamCount = parameters.Length;
}
return true;
}
private void ReflectOnApplicationType() {
ArrayList handlers = new ArrayList();
MethodInfo[] methods;
Debug.Trace("PipelineRuntime", "ReflectOnApplicationType");
// get this class methods
methods = _theApplicationType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
foreach (MethodInfo m in methods) {
if (ReflectOnMethodInfoIfItLooksLikeEventHandler(m))
handlers.Add(m);
}
// get base class private methods (GetMethods would not return those)
Type baseType = _theApplicationType.BaseType;
if (baseType != null && baseType != typeof(HttpApplication)) {
methods = baseType.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
foreach (MethodInfo m in methods) {
if (m.IsPrivate && ReflectOnMethodInfoIfItLooksLikeEventHandler(m))
handlers.Add(m);
}
}
// remember as an array
_eventHandlerMethods = new MethodInfo[handlers.Count];
for (int i = 0; i < _eventHandlerMethods.Length; i++)
_eventHandlerMethods[i] = (MethodInfo)handlers[i];
}
private void SetupChangesMonitor() {
FileChangeEventHandler handler = new FileChangeEventHandler(this.OnAppFileChange);
HttpRuntime.FileChangesMonitor.StartMonitoringFile(_appFilename, handler);
if (_fileDependencies != null) {
foreach (string fileName in _fileDependencies) {
HttpRuntime.FileChangesMonitor.StartMonitoringFile(
HostingEnvironment.MapPathInternal(fileName), handler);
}
}
}
private void OnAppFileChange(Object sender, FileChangeEvent e) {
// shutdown the app domain if app file changed
Debug.Trace("AppDomainFactory", "Shutting down appdomain because of application file change");
string message = FileChangesMonitor.GenerateErrorMessage(e.Action, e.FileName);
if (message == null) {
message = "Change in GLOBAL.ASAX";
}
HttpRuntime.ShutdownAppDomain(ApplicationShutdownReason.ChangeInGlobalAsax, message);
}
//
// Application instance management
//
private HttpApplication GetNormalApplicationInstance(HttpContext context) {
HttpApplication app = null;
lock (_freeList) {
if (_numFreeAppInstances > 0) {
app = (HttpApplication)_freeList.Pop();
_numFreeAppInstances--;
if (_numFreeAppInstances < _minFreeAppInstances) {
_minFreeAppInstances = _numFreeAppInstances;
}
}
}
if (app == null) {
// If ran out of instances, create a new one
app = (HttpApplication)HttpRuntime.CreateNonPublicInstance(_theApplicationType);
using (new ApplicationImpersonationContext()) {
app.InitInternal(context, _state, _eventHandlerMethods);
}
}
if (AppSettings.UseTaskFriendlySynchronizationContext) {
// When this HttpApplication instance is no longer in use, recycle it.
app.ApplicationInstanceConsumersCounter = new CountdownTask(1); // representing required call to HttpApplication.ReleaseAppInstance
app.ApplicationInstanceConsumersCounter.Task.ContinueWith((_, o) => RecycleApplicationInstance((HttpApplication)o), app, TaskContinuationOptions.ExecuteSynchronously);
}
return app;
}
private void RecycleNormalApplicationInstance(HttpApplication app) {
lock (_freeList) {
_freeList.Push(app);
_numFreeAppInstances++;
}
}
private void TrimApplicationInstanceFreeList(bool trimAll = false) {
// reset last min length
int minFreeAppInstances = _minFreeAppInstances;
_minFreeAppInstances = _numFreeAppInstances;
// if free list is empty or was empty since last trim, don't trim now
if (minFreeAppInstances <= 1) {
return;
}
ArrayList apps = null;
lock (_freeList) {
if (_numFreeAppInstances > 1) {
apps = new ArrayList();
// trim a percentage at a time or 1 item
int trimCount = (_numFreeAppInstances * 3)/100 + 1; // 3% at the time
while (trimCount > 0) {
apps.Add(_freeList.Pop());
_numFreeAppInstances--;
trimCount--;
}
_minFreeAppInstances = _numFreeAppInstances;
}
}
// dispose the applications that were removed (if any)
if (apps != null) {
foreach (HttpApplication app in apps) {
app.DisposeInternal();
}
}
}
internal static HttpApplication GetPipelineApplicationInstance(IntPtr appContext, HttpContext context) {
_theApplicationFactory.EnsureInited();
return _theApplicationFactory.GetSpecialApplicationInstance(appContext, context);
}
internal static void RecyclePipelineApplicationInstance(HttpApplication app) {
_theApplicationFactory.RecycleSpecialApplicationInstance(app);
}
private HttpApplication GetSpecialApplicationInstance(IntPtr appContext, HttpContext context) {
HttpApplication app = null;
lock (_specialFreeList) {
if (_numFreeSpecialAppInstances > 0) {
app = (HttpApplication)_specialFreeList.Pop();
_numFreeSpecialAppInstances--;
}
}
if (app == null) {
//
// Put the context on the thread, to make it available to anyone calling
// HttpContext.Current from the HttpApplication constructor or module Init
//
using (new DisposableHttpContextWrapper(context)) {
// If ran out of instances, create a new one
app = (HttpApplication)HttpRuntime.CreateNonPublicInstance(_theApplicationType);
using (new ApplicationImpersonationContext()) {
app.InitSpecial(_state, _eventHandlerMethods, appContext, context);
}
}
}
return app;
}
private HttpApplication GetSpecialApplicationInstance() {
return GetSpecialApplicationInstance(IntPtr.Zero, null);
}
private void RecycleSpecialApplicationInstance(HttpApplication app) {
if (_numFreeSpecialAppInstances < _maxFreeSpecialAppInstances) {
lock (_specialFreeList) {
_specialFreeList.Push(app);
_numFreeSpecialAppInstances++;
}
}
// else: don't dispose these
}
//
// Application on_start / on_end
//
private void FireApplicationOnStart(HttpContext context) {
if (_onStartMethod != null) {
HttpApplication app = GetSpecialApplicationInstance();
app.ProcessSpecialRequest(
context,
_onStartMethod,
_onStartParamCount,
this,
EventArgs.Empty,
null);
RecycleSpecialApplicationInstance(app);
}
}
private void FireApplicationOnEnd() {
if (_onEndMethod != null) {
HttpApplication app = GetSpecialApplicationInstance();
app.ProcessSpecialRequest(
null,
_onEndMethod,
_onEndParamCount,
this,
EventArgs.Empty,
null);
RecycleSpecialApplicationInstance(app);
}
}
//
// Session on_start / on_end
//
class AspCompatSessionOnEndHelper {
private HttpApplication _app;
private HttpSessionState _session;
private Object _eventSource;
private EventArgs _eventArgs;
internal AspCompatSessionOnEndHelper(HttpApplication app, HttpSessionState session, Object eventSource, EventArgs eventArgs) {
_app = app;
_session = session;
_eventSource = eventSource;
_eventArgs = eventArgs;
}
internal HttpApplication Application { get { return _app; } }
internal HttpSessionState Session { get { return _session; } }
internal Object Source { get { return _eventSource; } }
internal EventArgs Args { get { return _eventArgs; } }
}
private void SessionOnEndEventHandlerAspCompatHelper(Object eventSource, EventArgs eventArgs) {
AspCompatSessionOnEndHelper helper = (AspCompatSessionOnEndHelper)eventSource;
helper.Application.ProcessSpecialRequest(
null,
_sessionOnEndMethod,
_sessionOnEndParamCount,
helper.Source,
helper.Args,
helper.Session);
}
private void FireSessionOnEnd(HttpSessionState session, Object eventSource, EventArgs eventArgs) {
if (_sessionOnEndMethod != null) {
HttpApplication app = GetSpecialApplicationInstance();
#if !FEATURE_PAL // FEATURE_PAL does not enable COM
if (AspCompatApplicationStep.AnyStaObjectsInSessionState(session) || HttpRuntime.ApartmentThreading) {
AspCompatSessionOnEndHelper helper = new AspCompatSessionOnEndHelper(app, session, eventSource, eventArgs);
AspCompatApplicationStep.RaiseAspCompatEvent(
null,
app,
session.SessionID,
_sessionOnEndEventHandlerAspCompatHelper,
helper,
EventArgs.Empty);
}
else {
#endif // !FEATURE_PAL
app.ProcessSpecialRequest(
null,
_sessionOnEndMethod,
_sessionOnEndParamCount,
eventSource,
eventArgs,
session);
#if !FEATURE_PAL // FEATURE_PAL does not enable COM
}
#endif // !FEATURE_PAL
RecycleSpecialApplicationInstance(app);
}
}
private void FireApplicationOnError(Exception error) {
HttpApplication app = GetSpecialApplicationInstance();
app.RaiseErrorWithoutContext(error);
RecycleSpecialApplicationInstance(app);
}
//
// Dispose resources associated with the app factory
//
private void Dispose() {
// dispose all 'normal' application instances
DisposeHttpApplicationInstances(_freeList, ref _numFreeAppInstances);
// call application_onEnd (only if application_onStart was called before)
if (_appOnStartCalled && !_appOnEndCalled) {
lock (this) {
if (!_appOnEndCalled) {
FireApplicationOnEnd();
_appOnEndCalled = true;
}
}
}
// dispose all 'special' application instances (DevDiv #109006)
if (!AppSettings.DoNotDisposeSpecialHttpApplicationInstances) {
DisposeHttpApplicationInstances(_specialFreeList, ref _numFreeSpecialAppInstances);
}
}
private static void DisposeHttpApplicationInstances(Stack freeList, ref int numFreeInstances) {
// freeList is the stack of HttpApplication instances, and numFreeInstances is the number of elements we're allowed to pop from the stack
List<HttpApplication> instances;
lock (freeList) {
instances = new List<HttpApplication>(numFreeInstances); // access 'numFreeInstances' only from within the lock
for (; numFreeInstances > 0; numFreeInstances--) {
instances.Add((HttpApplication)freeList.Pop());
}
}
// dispose of each instance outside the lock
foreach (HttpApplication instance in instances) {
instance.DisposeInternal();
}
}
//
// Static methods for outside use
//
// custom application -- every request goes directly to the same handler
private static IHttpHandler _customApplication;
internal static void SetCustomApplication(IHttpHandler customApplication) {
// ignore this in app domains where we execute requests (ASURT 128047)
if (HttpRuntime.AppDomainAppId == null) // only if 'clean' app domain
_customApplication = customApplication;
}
internal static IHttpHandler GetApplicationInstance(HttpContext context) {
if (_customApplication != null)
return _customApplication;
// Check to see if it's a debug auto-attach request
if (context.Request.IsDebuggingRequest)
return new HttpDebugHandler();
_theApplicationFactory.EnsureInited();
_theApplicationFactory.EnsureAppStartCalled(context);
return _theApplicationFactory.GetNormalApplicationInstance(context);
}
internal static void RecycleApplicationInstance(HttpApplication app) {
_theApplicationFactory.RecycleNormalApplicationInstance(app);
}
internal static void TrimApplicationInstances(bool removeAll = false) {
if (_theApplicationFactory != null) {
if (removeAll) {
// Remove all pooled HttpApplication instances (potentially reclaiming memory eagerly)
DisposeHttpApplicationInstances(_theApplicationFactory._freeList, ref _theApplicationFactory._numFreeAppInstances);
}
else {
// Remove only some pooled HttpApplication instances
_theApplicationFactory.TrimApplicationInstanceFreeList();
}
}
}
internal static void EndApplication() {
_theApplicationFactory.Dispose();
}
internal static void EndSession(HttpSessionState session, Object eventSource, EventArgs eventArgs) {
_theApplicationFactory.FireSessionOnEnd(session, eventSource, eventArgs);
}
internal static void RaiseError(Exception error) {
_theApplicationFactory.EnsureInited(); // VSWhidbey 482346
_theApplicationFactory.FireApplicationOnError(error);
}
internal static HttpApplicationState ApplicationState {
get {
HttpApplicationState state = _theApplicationFactory._state;
if (state == null)
state = new HttpApplicationState();
return state;
}
}
}
}