internal static void PreloadApplicationIfNotShuttingdown (string appId, LockableAppDomainContext ac) {
     // If GL_STOP_LISTENING wasn't triggered, the reset is likely due to a configuration change.
     if (ProcessHost.DefaultHost != null && !HostingEnvironment.StopListeningWasCalled) {
         // Start the new app on another thread instead of hijacking the current app unloading thread
         ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object o) {
             lock (ac) {
                 try {
                     // NOTE: we don't know what HostingEnvironmentParameters were passed to our previous application instance
                     // so we pass null (default for HTTP activation). We could have cached it in ApplicationContext if needed
                     ProcessHost.DefaultHost.PreloadApplicationIfRequired(appId, null, null, ac);
                 }
                 catch (Exception e) {
                     ProcessHost.DefaultHost.ReportApplicationPreloadFailureWithAssert(
                         ac.PreloadContext,
                         HResults.E_FAIL,
                         Misc.FormatExceptionMessage(
                             e, new string[] { 
                                 SR.GetString(SR.Failure_Preload_Application_Initialization)}));
                 }
             }
         }));
     }
 }
 internal LockableAppDomainContext GetLockableAppDomainContext(string appId)
 {
     lock (this)
     {
         LockableAppDomainContext context;
         if (!this._appDomains.TryGetValue(appId, out context))
         {
             context = new LockableAppDomainContext();
             this._appDomains.Add(appId, context);
         }
         return context;
     }
 }
        // New for Dev10. 
        // creates a new AppDomain, preloads and calls user code in it
        internal void PreloadApplicationIfRequired(
                string appId, 
                IApplicationHost appHostParameter,
                HostingEnvironmentParameters hostingParameters, 
                LockableAppDomainContext ac) {

            // NOTE1:  Must never be called under lock (_appManager)
            // NOTE2:  Must always be called under lock (ac)
    
            // We only need to preload if auto start is enabled and we have not already preloaded (i.e. HostingEnvironment doesn't exist)
            if (_preloadUtil == null || ac.PreloadContext == null || ac.HostEnv != null) {
                return;
            }

            // Get and verify the preload parameters 
            string preloadObjTypeName;
            string[] paramsForStartupObj;
            bool stillEnabled;

            GetApplicationPreloadInfoWithAssert(ac.PreloadContext, out stillEnabled, out preloadObjTypeName, out paramsForStartupObj);
            
            // Dev10: 782385	ASP.NET autostart implementation should be tolerant of empty string for the provider type
            if (!stillEnabled || String.IsNullOrEmpty(preloadObjTypeName)) {
                return;
            }

            // Ready to load the App Domain
            if (_preloadingThrottle != null) {
                // Throttle the number of simultaneously created appdomains
                _preloadingThrottle.WaitOne();
            }

            try {
                
                // Create the app-host and start a new App Domain
                IApplicationHost appHost = (appHostParameter == null) ? CreateAppHost(appId, null) : appHostParameter;
                
                // call app manager to create the PreloadHost
                PreloadHost preloadHostObj = (PreloadHost)_appManager.CreateObjectInternal(
                    appId, 
                    typeof(PreloadHost), 
                    appHost, 
                    true /*failIfExists*/, 
                    hostingParameters);
                
                // Dev10 858421:  File sharing violations on config files cause unnecessary process shutdown in autostart mode
                // 
                // There are race conditions between whoever modifies the config files 
                // and the application config system that reads from the config files
                // These file sharing violation lead to random application initialization failures
                // Service auto-start mode is more vulnerable to these sharing violations because 
                // it starts a new app domain as soon as the file change notification is received
                // and when an error occurs IIS recycles the whole app pool rather than a particular app
                // 
                // In most cases that we see in stress the inner most exception is System.IO.IOException 
                // so if we see this exception we will give it another try before
                // reporting the errors to IIS and recycling the process
                // 

                // Check for I/O exceptions during initialization and retry one time
                Exception appInitEx = preloadHostObj.InitializationException;
                if (GetInnerMostException(appInitEx) is IOException) {
                    try {
                        // prevent ApplicationManager.HostingEnvironmentShutdownInitiated from attempting to preload again
                        ac.RetryingPreload = true;
                        // shutdown old hosting environment
                        ac.HostEnv.InitiateShutdownInternal();
                    }
                    finally {
                        ac.RetryingPreload = false;
                    }

                    // Create the app-host and start a new App Domain
                    appHost = (appHostParameter == null) ? CreateAppHost(appId, null) : appHostParameter;
                
                    // call app manager to create the PreloadHost
                    preloadHostObj = (PreloadHost)_appManager.CreateObjectInternal(
                        appId, 
                        typeof(PreloadHost), 
                        appHost, 
                        true /*failIfExists*/, 
                        hostingParameters);

                    appInitEx = preloadHostObj.InitializationException;
                }

                // Check again for initialization exception and tell IIS to recycle the process
                if (appInitEx != null) {
                    ReportApplicationPreloadFailureWithAssert(
                        ac.PreloadContext,
                        HResults.E_FAIL,
                        Misc.FormatExceptionMessage(
                            appInitEx, new string[] { 
                                SR.GetString(SR.Failure_Preload_Application_Initialization)} ));

                    // we must throw if preload fails because we cannot allow the normal
                    // startup path to continue and attempt to create a HostingEnvironment
                    throw appInitEx;
                }

                // Call preload code in the App Domain
                try {
                    preloadHostObj.CreateIProcessHostPreloadClientInstanceAndCallPreload(preloadObjTypeName, paramsForStartupObj);
                }
                catch (Exception e) {
                    // report errors
                    ReportApplicationPreloadFailureWithAssert(
                        ac.PreloadContext,
                        HResults.E_FAIL,
                        Misc.FormatExceptionMessage(
                            e, new string[] {
                                SR.GetString(SR.Failure_Calling_Preload_Provider)} ).ToString());

                    throw;
                }
            }
            finally {
                if (_preloadingThrottle != null) {
                    _preloadingThrottle.Release();
                }
            }

        }
示例#4
0
 internal void PreloadApplicationIfRequired(string appId, IApplicationHost appHostParameter, HostingEnvironmentParameters hostingParameters, LockableAppDomainContext ac)
 {
     if (((this._preloadUtil != null) && (ac.PreloadContext != null)) && (ac.HostEnv == null))
     {
         string   str;
         string[] strArray;
         bool     flag;
         this.GetApplicationPreloadInfoWithAssert(ac.PreloadContext, out flag, out str, out strArray);
         if (flag && !string.IsNullOrEmpty(str))
         {
             if (this._preloadingThrottle != null)
             {
                 this._preloadingThrottle.WaitOne();
             }
             try
             {
                 IApplicationHost appHost = (appHostParameter == null) ? this.CreateAppHost(appId, null) : appHostParameter;
                 PreloadHost      host2   = (PreloadHost)this._appManager.CreateObjectInternal(appId, typeof(PreloadHost), appHost, true, hostingParameters);
                 Exception        initializationException = host2.InitializationException;
                 if (GetInnerMostException(initializationException) is IOException)
                 {
                     try
                     {
                         ac.RetryingPreload = true;
                         ac.HostEnv.InitiateShutdownInternal();
                     }
                     finally
                     {
                         ac.RetryingPreload = false;
                     }
                     appHost = (appHostParameter == null) ? this.CreateAppHost(appId, null) : appHostParameter;
                     host2   = (PreloadHost)this._appManager.CreateObjectInternal(appId, typeof(PreloadHost), appHost, true, hostingParameters);
                     initializationException = host2.InitializationException;
                 }
                 if (initializationException != null)
                 {
                     this.ReportApplicationPreloadFailureWithAssert(ac.PreloadContext, -2147467259, Misc.FormatExceptionMessage(initializationException, new string[] { System.Web.SR.GetString("Failure_Preload_Application_Initialization") }));
                     throw initializationException;
                 }
                 try
                 {
                     host2.CreateIProcessHostPreloadClientInstanceAndCallPreload(str, strArray);
                 }
                 catch (Exception exception2)
                 {
                     this.ReportApplicationPreloadFailureWithAssert(ac.PreloadContext, -2147467259, Misc.FormatExceptionMessage(exception2, new string[] { System.Web.SR.GetString("Failure_Calling_Preload_Provider") }).ToString());
                     throw;
                 }
             }
             finally
             {
                 if (this._preloadingThrottle != null)
                 {
                     this._preloadingThrottle.Release();
                 }
             }
         }
     }
 }