|
//------------------------------------------------------------------------------
// <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.Collections.Concurrent;
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 ConcurrentBag<HttpApplication> _freeList = new ConcurrentBag<HttpApplication>();
// free list of special (context-less) app objects
// to be used for global events (App_OnEnd, Session_OnEnd, etc.)
private ConcurrentBag<HttpApplication> _specialFreeList = new ConcurrentBag<HttpApplication>();
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;
if (!_freeList.TryTake(out app)) {
// 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) {
_freeList.Add(app);
}
private void TrimApplicationInstanceFreeList(bool trimAll = false) {
int freeAppInstances = _freeList.Count;
if (freeAppInstances <= 1) {
return;
}
int trimCount = (freeAppInstances * 3)/100 + 1; // 3% at the time
DisposeHttpApplicationInstances(_freeList, trimCount);
}
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;
if (!_specialFreeList.TryTake(out app)) {
//
// 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 (_specialFreeList.Count < _maxFreeSpecialAppInstances) {
_specialFreeList.Add(app);
}
// 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, _freeList.Count);
// 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, _specialFreeList.Count);
}
}
private static void DisposeHttpApplicationInstances(ConcurrentBag<HttpApplication> freeList, int numOfInstancesToDispose) {
if(numOfInstancesToDispose <= 0) {
return;
}
List<HttpApplication> instances = new List<HttpApplication>();
HttpApplication appToDispose = null;
for(int i = 0; i < numOfInstancesToDispose; i++) {
if(freeList.TryTake(out appToDispose)) {
instances.Add(appToDispose);
}
else {
break;
}
}
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, _theApplicationFactory._freeList.Count);
}
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;
}
}
}
}
|