static internal IConfigMapPath GetInstance() { // IIS 7 bits on <= IIS 6.x: use the metabase if (ServerConfig.UseMetabase) { return((IConfigMapPath)MetabaseServerConfig.GetInstance()); } if (ServerConfig.IISExpressVersion != null) { return((IConfigMapPath)ServerConfig.GetInstance()); } ProcessHost host = ProcessHost.DefaultHost; IProcessHostSupportFunctions functions = null; if (null != host) { functions = host.SupportFunctions; } if (functions == null) { functions = HostingEnvironment.SupportFunctions; } return(new ProcessHostMapPath(functions)); }
internal ProcessHostMapPath(IProcessHostSupportFunctions functions) { // if the functions are null and we're // not in a worker process, init the mgdeng config system if (null == functions) { ProcessHostConfigUtils.InitStandaloneConfig(); } // we need to explicit create a COM proxy in this app domain // so we don't go back to the default domain or have lifetime issues if (null != functions) { _functions = Misc.CreateLocalSupportFunctions(functions); } // proactive set the config functions for // webengine in case this is a TCP init path if (null != _functions ) { IntPtr configSystem = _functions.GetNativeConfigurationSystem(); Debug.Assert(IntPtr.Zero != configSystem, "null != configSystem"); if (IntPtr.Zero != configSystem) { // won't fail if valid pointer // no cleanup needed, we don't own instance UnsafeIISMethods.MgdSetNativeConfiguration(configSystem); } } }
internal ProcessHostMapPath(IProcessHostSupportFunctions functions) { // if the functions are null and we're // not in a worker process, init the mgdeng config system if (null == functions) { ProcessHostConfigUtils.InitStandaloneConfig(); } // we need to explicit create a COM proxy in this app domain // so we don't go back to the default domain or have lifetime issues if (null != functions) { _functions = Misc.CreateLocalSupportFunctions(functions); } // proactive set the config functions for // webengine in case this is a TCP init path if (null != _functions) { IntPtr configSystem = _functions.GetNativeConfigurationSystem(); Debug.Assert(IntPtr.Zero != configSystem, "null != configSystem"); if (IntPtr.Zero != configSystem) { // won't fail if valid pointer // no cleanup needed, we don't own instance UnsafeIISMethods.MgdSetNativeConfiguration(configSystem); } } }
internal static IProcessHostSupportFunctions CreateLocalSupportFunctions(IProcessHostSupportFunctions proxyFunctions) { IProcessHostSupportFunctions objectForIUnknown = null; IntPtr iUnknownForObject = Marshal.GetIUnknownForObject(proxyFunctions); if (IntPtr.Zero == iUnknownForObject) { return null; } IntPtr zero = IntPtr.Zero; try { Guid gUID = typeof(IProcessHostSupportFunctions).GUID; int errorCode = Marshal.QueryInterface(iUnknownForObject, ref gUID, out zero); if (errorCode < 0) { Marshal.ThrowExceptionForHR(errorCode); } objectForIUnknown = (IProcessHostSupportFunctions) Marshal.GetObjectForIUnknown(zero); } finally { if (IntPtr.Zero != zero) { Marshal.Release(zero); } if (IntPtr.Zero != iUnknownForObject) { Marshal.Release(iUnknownForObject); } } return objectForIUnknown; }
internal static IProcessHostSupportFunctions CreateLocalSupportFunctions(IProcessHostSupportFunctions proxyFunctions) { IProcessHostSupportFunctions objectForIUnknown = null; IntPtr iUnknownForObject = Marshal.GetIUnknownForObject(proxyFunctions); if (IntPtr.Zero == iUnknownForObject) { return(null); } IntPtr zero = IntPtr.Zero; try { Guid gUID = typeof(IProcessHostSupportFunctions).GUID; int errorCode = Marshal.QueryInterface(iUnknownForObject, ref gUID, out zero); if (errorCode < 0) { Marshal.ThrowExceptionForHR(errorCode); } objectForIUnknown = (IProcessHostSupportFunctions)Marshal.GetObjectForIUnknown(zero); } finally { if (IntPtr.Zero != zero) { Marshal.Release(zero); } if (IntPtr.Zero != iUnknownForObject) { Marshal.Release(iUnknownForObject); } } return(objectForIUnknown); }
ProcessHostServerConfig() { if (null == HostingEnvironment.SupportFunctions) { ProcessHostConfigUtils.InitStandaloneConfig(); } else { IProcessHostSupportFunctions fns = HostingEnvironment.SupportFunctions; if (null != fns) { IntPtr configSystem = fns.GetNativeConfigurationSystem(); Debug.Assert(IntPtr.Zero != configSystem, "null != configSystem"); if (IntPtr.Zero != configSystem) { // won't fail if valid pointer // no cleanup needed, we don't own instance UnsafeIISMethods.MgdSetNativeConfiguration(configSystem); } } } _siteNameForCurrentApplication = HostingEnvironment.SiteNameNoDemand; if (_siteNameForCurrentApplication == null) { _siteNameForCurrentApplication = ProcessHostConfigUtils.GetSiteNameFromId(ProcessHostConfigUtils.DEFAULT_SITE_ID_UINT); } }
internal ISAPIApplicationHost(string appIdOrVirtualPath, string physicalPath, bool validatePhysicalPath, IProcessHostSupportFunctions functions, string iisVersion = null) { _iisVersion = iisVersion; // appIdOrVirtualPath is either a full metabase path, or just a virtual path // e.g. /LM/W3SVC/1/Root/MyApp ot /MyApp // Figure out which one we have, and get the other one from it _functions = functions; // make sure the functions are set in the default domain if (null == _functions) { ProcessHost h = ProcessHost.DefaultHost; if (null != h) { _functions = h.SupportFunctions; if (null != _functions) { HostingEnvironment.SupportFunctions = _functions; } } } IServerConfig serverConfig = ServerConfig.GetDefaultDomainInstance(_iisVersion); if (StringUtil.StringStartsWithIgnoreCase(appIdOrVirtualPath, LMW3SVC_PREFIX)) { _appId = appIdOrVirtualPath; _virtualPath = VirtualPath.Create(ExtractVPathFromAppId(_appId)); _siteID = ExtractSiteIdFromAppId(_appId); _siteName = serverConfig.GetSiteNameFromSiteID(_siteID); } else { _virtualPath = VirtualPath.Create(appIdOrVirtualPath); _appId = GetDefaultAppIdFromVPath(_virtualPath.VirtualPathString); _siteID = DEFAULT_SITEID; _siteName = serverConfig.GetSiteNameFromSiteID(_siteID); } // Get the physical path from the virtual path if it wasn't passed in if (physicalPath == null) { _physicalPath = serverConfig.MapPath(this, _virtualPath); } else { _physicalPath = physicalPath; } if (validatePhysicalPath) { if (!Directory.Exists(_physicalPath)) { throw new HttpException(SR.GetString(SR.Invalid_IIS_app, appIdOrVirtualPath)); } } }
public Object GetProcessHost(IProcessHostSupportFunctions functions) { try { return ProcessHost.GetProcessHost(functions); } catch(Exception e) { Misc.ReportUnhandledException(e, new string[] {SR.GetString(SR.Cant_Create_Process_Host)}); throw; } }
public Object GetProcessHost(IProcessHostSupportFunctions functions) { try { return(ProcessHost.GetProcessHost(functions)); } catch (Exception e) { Misc.ReportUnhandledException(e, new string[] { SR.GetString(SR.Cant_Create_Process_Host) }); throw; } }
public object GetProcessHost(IProcessHostSupportFunctions functions) { object processHost; try { processHost = ProcessHost.GetProcessHost(functions); } catch (Exception exception) { Misc.ReportUnhandledException(exception, new string[] { System.Web.SR.GetString("Cant_Create_Process_Host") }); throw; } return processHost; }
internal static ProcessHost GetProcessHost(IProcessHostSupportFunctions functions) { if (_theProcessHost == null) { lock (_processHostStaticLock) { if (_theProcessHost == null) { _theProcessHost = new ProcessHost(functions); } } } return(_theProcessHost); }
public object GetProcessHost(IProcessHostSupportFunctions functions) { object processHost; try { processHost = ProcessHost.GetProcessHost(functions); } catch (Exception exception) { Misc.ReportUnhandledException(exception, new string[] { System.Web.SR.GetString("Cant_Create_Process_Host") }); throw; } return(processHost); }
internal ISAPIApplicationHost(string appIdOrVirtualPath, string physicalPath, bool validatePhysicalPath, IProcessHostSupportFunctions functions, string iisVersion = null) { this._iisVersion = iisVersion; this._functions = functions; if (this._functions == null) { ProcessHost defaultHost = ProcessHost.DefaultHost; if (defaultHost != null) { this._functions = defaultHost.SupportFunctions; if (this._functions != null) { HostingEnvironment.SupportFunctions = this._functions; } } } IServerConfig defaultDomainInstance = ServerConfig.GetDefaultDomainInstance(this._iisVersion); if (StringUtil.StringStartsWithIgnoreCase(appIdOrVirtualPath, "/LM/W3SVC/")) { this._appId = appIdOrVirtualPath; this._virtualPath = VirtualPath.Create(ExtractVPathFromAppId(this._appId)); this._siteID = ExtractSiteIdFromAppId(this._appId); this._siteName = defaultDomainInstance.GetSiteNameFromSiteID(this._siteID); } else { this._virtualPath = VirtualPath.Create(appIdOrVirtualPath); this._appId = GetDefaultAppIdFromVPath(this._virtualPath.VirtualPathString); this._siteID = "1"; this._siteName = defaultDomainInstance.GetSiteNameFromSiteID(this._siteID); } if (physicalPath == null) { this._physicalPath = defaultDomainInstance.MapPath(this, this._virtualPath); } else { this._physicalPath = physicalPath; } if (validatePhysicalPath && !Directory.Exists(this._physicalPath)) { throw new HttpException(System.Web.SR.GetString("Invalid_IIS_app", new object[] { appIdOrVirtualPath })); } }
internal static IProcessHostSupportFunctions CreateLocalSupportFunctions(IProcessHostSupportFunctions proxyFunctions) { IProcessHostSupportFunctions localFunctions = null; // get the underlying COM object IntPtr pUnk = Marshal.GetIUnknownForObject(proxyFunctions); // this object isn't a COM object if (IntPtr.Zero == pUnk) { return(null); } IntPtr ppv = IntPtr.Zero; try { // QI it for the interface Guid g = typeof(IProcessHostSupportFunctions).GUID; int hresult = Marshal.QueryInterface(pUnk, ref g, out ppv); if (hresult < 0) { Marshal.ThrowExceptionForHR(hresult); } // create a RCW we can hold onto in this domain // this bumps the ref count so we can drop our refs on the raw interfaces localFunctions = (IProcessHostSupportFunctions)Marshal.GetObjectForIUnknown(ppv); } finally { // drop our explicit refs and keep the managed instance if (IntPtr.Zero != ppv) { Marshal.Release(ppv); } if (IntPtr.Zero != pUnk) { Marshal.Release(pUnk); } } return(localFunctions); }
internal ProcessHostMapPath(IProcessHostSupportFunctions functions) { if (functions == null) { ProcessHostConfigUtils.InitStandaloneConfig(); } if (functions != null) { this._functions = Misc.CreateLocalSupportFunctions(functions); } if (this._functions != null) { IntPtr nativeConfigurationSystem = this._functions.GetNativeConfigurationSystem(); if (IntPtr.Zero != nativeConfigurationSystem) { UnsafeIISMethods.MgdSetNativeConfiguration(nativeConfigurationSystem); } } this._mapPathCacheLock = new object(); }
// Use this instead of MapPath, as it encapsulates the correct way to invoke // the MapPath method. Didn't bother much with efficiency since it's called // so few times. // // Example inputs: MapPathInternal(appId, "/appVPath", "/bin/foo.dll"); public static string MapPathInternal(this IProcessHostSupportFunctions supportFunctions, string appId, string appVirtualPath, string relativePath) { Debug.Assert(supportFunctions != null); Debug.Assert(!String.IsNullOrWhiteSpace(appId)); Debug.Assert(!String.IsNullOrWhiteSpace(appVirtualPath) && appVirtualPath[0] == '/'); Debug.Assert(relativePath != null); StringBuilder fullVirtualPath = new StringBuilder(appVirtualPath.Length + relativePath.Length + 2 /* for slashes */); // Ensure the app virtual path is always preceded by a slash if (appVirtualPath[0] != '/') { fullVirtualPath.Append('/'); } fullVirtualPath.Append(appVirtualPath); // Ensure the app virtual path always ends with a slash if (fullVirtualPath[fullVirtualPath.Length - 1] != '/') { fullVirtualPath.Append('/'); } // Append the relative path, removing the preceding slash if necessary if (relativePath.Length > 0) { if (relativePath[0] == '/') { fullVirtualPath.Append(relativePath, 1, relativePath.Length - 1); } else { fullVirtualPath.Append(relativePath); } } string physicalPath; supportFunctions.MapPath(appId, fullVirtualPath.ToString(), out physicalPath); return(physicalPath); }
private ProcessHost(IProcessHostSupportFunctions functions) { try { this._functions = functions; HostingEnvironment.SupportFunctions = functions; this._appManager = ApplicationManager.GetApplicationManager(); int initialCount = (int)Misc.GetAspNetRegValue(null, "MaxPreloadConcurrency", 0); if (initialCount > 0) { this._preloadingThrottle = new Semaphore(initialCount, initialCount); } } catch (Exception exception) { using (new ProcessImpersonationContext()) { Misc.ReportUnhandledException(exception, new string[] { System.Web.SR.GetString("Cant_Create_Process_Host") }); } throw; } }
internal static IConfigMapPath GetInstance() { if (ServerConfig.UseMetabase) { return((IConfigMapPath)MetabaseServerConfig.GetInstance()); } if (ServerConfig.IISExpressVersion != null) { return((IConfigMapPath)ServerConfig.GetInstance()); } ProcessHost defaultHost = ProcessHost.DefaultHost; IProcessHostSupportFunctions supportFunctions = null; if (defaultHost != null) { supportFunctions = defaultHost.SupportFunctions; } if (supportFunctions == null) { supportFunctions = HostingEnvironment.SupportFunctions; } return(new ProcessHostMapPath(supportFunctions)); }
private ProcessHostServerConfig() { if (HostingEnvironment.SupportFunctions == null) { ProcessHostConfigUtils.InitStandaloneConfig(); } else { IProcessHostSupportFunctions supportFunctions = HostingEnvironment.SupportFunctions; if (supportFunctions != null) { IntPtr nativeConfigurationSystem = supportFunctions.GetNativeConfigurationSystem(); if (IntPtr.Zero != nativeConfigurationSystem) { UnsafeIISMethods.MgdSetNativeConfiguration(nativeConfigurationSystem); } } } this._siteNameForCurrentApplication = HostingEnvironment.SiteNameNoDemand; if (this._siteNameForCurrentApplication == null) { this._siteNameForCurrentApplication = ProcessHostConfigUtils.GetSiteNameFromId(1); } }
IObjectHandle IProcessHostLite.GetCustomLoader(string appId, string appConfigPath, out IProcessHostSupportFunctions supportFunctions, out AppDomain newlyCreatedAppDomain) { supportFunctions = null; newlyCreatedAppDomain = null; CustomLoaderHelperFunctions helperFunctions = new CustomLoaderHelperFunctions(_functions, appId); string appVirtualPath = helperFunctions.AppVirtualPath; try { string customLoaderAssemblyPhysicalPath = helperFunctions.MapPath("bin/AspNet.Loader.dll"); if (!File.Exists(customLoaderAssemblyPhysicalPath)) { return null; // no custom loader is in use; fall back to legacy hosting logic } // Technically there is a race condition between the file existence check above // and the assembly load that will take place shortly. We won't worry too much // about this since the window is very short and the application shouldn't be // modified during this process anyway. string appRootPhysicalPath = helperFunctions.AppPhysicalPath; string webConfigPhysicalPath = helperFunctions.MapPath("Web.config"); bool webConfigFileExists = File.Exists(webConfigPhysicalPath); // The CustomLoaderHelper class is defined in System.Web.ApplicationServices.dll // so that OOB frameworks don't need to take a hardcoded System.Web.dll dependency. // There might be weird issues if we try to load a GACed System.Web.dll into the // same AppDomain as a bin-deployed System.Web.dll. supportFunctions = _functions; return CustomLoaderHelper.GetCustomLoader( helperFunctions: helperFunctions, appConfigMetabasePath: appConfigPath, configFilePath: (webConfigFileExists) ? webConfigPhysicalPath : null, customLoaderPhysicalPath: customLoaderAssemblyPhysicalPath, newlyCreatedAppDomain: out newlyCreatedAppDomain); } catch (Exception ex) { SetCustomLoaderFailure(appId, ExceptionDispatchInfo.Capture(ex)); return null; } }
// Methods public virtual object GetProcessHost(IProcessHostSupportFunctions functions) { }
// Methods public virtual object GetProcessHost(IProcessHostSupportFunctions functions) {}
internal static IProcessHostSupportFunctions CreateLocalSupportFunctions(IProcessHostSupportFunctions proxyFunctions) { IProcessHostSupportFunctions localFunctions = null; // get the underlying COM object IntPtr pUnk = Marshal.GetIUnknownForObject(proxyFunctions); // this object isn't a COM object if (IntPtr.Zero == pUnk) { return null; } IntPtr ppv = IntPtr.Zero; try { // QI it for the interface Guid g = typeof(IProcessHostSupportFunctions).GUID; int hresult = Marshal.QueryInterface(pUnk, ref g, out ppv); if (hresult < 0) { Marshal.ThrowExceptionForHR(hresult); } // create a RCW we can hold onto in this domain // this bumps the ref count so we can drop our refs on the raw interfaces localFunctions = (IProcessHostSupportFunctions)Marshal.GetObjectForIUnknown(ppv); } finally { // drop our explicit refs and keep the managed instance if (IntPtr.Zero != ppv) { Marshal.Release(ppv); } if (IntPtr.Zero != pUnk) { Marshal.Release(pUnk); } } return localFunctions; }
public Object GetProcessHost(IProcessHostSupportFunctions functions) { return default(Object); }
internal void Initialize(ApplicationManager appManager, IApplicationHost appHost, IConfigMapPathFactory configMapPathFactory, HostingEnvironmentParameters hostingParameters, PolicyLevel policyLevel, Exception appDomainCreationException) { _hostingParameters = hostingParameters; HostingEnvironmentFlags hostingFlags = HostingEnvironmentFlags.Default; if (_hostingParameters != null) { hostingFlags = _hostingParameters.HostingFlags; if (_hostingParameters.IISExpressVersion != null) { ServerConfig.IISExpressVersion = _hostingParameters.IISExpressVersion; } } // Keep track of the app manager, unless HideFromAppManager flag was passed if ((hostingFlags & HostingEnvironmentFlags.HideFromAppManager) == 0) _appManager = appManager; if ((hostingFlags & HostingEnvironmentFlags.ClientBuildManager) != 0) { BuildManagerHost.InClientBuildManager = true; } if ((hostingFlags & HostingEnvironmentFlags.SupportsMultiTargeting) != 0) { BuildManagerHost.SupportsMultiTargeting = true; } // // init config system using private config if applicable // if (appHost is ISAPIApplicationHost && !ServerConfig.UseMetabase) { string rootWebConfigPath = ((ISAPIApplicationHost)appHost).ResolveRootWebConfigPath(); if (!String.IsNullOrEmpty(rootWebConfigPath)) { Debug.Assert(File.Exists(rootWebConfigPath), "File.Exists(rootWebConfigPath)"); HttpConfigurationSystem.RootWebConfigurationFilePath = rootWebConfigPath; } // we need to explicit create a COM proxy in this app domain // so we don't go back to the default domain or have lifetime issues // remember support functions IProcessHostSupportFunctions proxyFunctions = ((ISAPIApplicationHost)appHost).SupportFunctions; if (null != proxyFunctions) { _functions = Misc.CreateLocalSupportFunctions(proxyFunctions); } } _appId = HttpRuntime.AppDomainAppId; _appVirtualPath = HttpRuntime.AppDomainAppVirtualPathObject; _appPhysicalPath = HttpRuntime.AppDomainAppPathInternal; _appHost = appHost; _configMapPath = configMapPathFactory.Create(_appVirtualPath.VirtualPathString, _appPhysicalPath); HttpConfigurationSystem.EnsureInit(_configMapPath, true, false); // attempt to cache and use IConfigMapPath2 provider // which supports VirtualPath's to save on conversions _configMapPath2 = _configMapPath as IConfigMapPath2; _initiateShutdownWorkItemCallback = new WaitCallback(this.InitiateShutdownWorkItemCallback); // notify app manager if (_appManager != null) { _appManager.HostingEnvironmentActivated(CacheMemorySizePressure.EffectiveProcessMemoryLimit); } // make sure there is always app host if (_appHost == null) { _appHost = new SimpleApplicationHost(_appVirtualPath, _appPhysicalPath); } else { _externalAppHost = true; } // remember the token to access config _configToken = _appHost.GetConfigToken(); // Start with a MapPath based virtual path provider _mapPathBasedVirtualPathProvider = new MapPathBasedVirtualPathProvider(); _virtualPathProvider = _mapPathBasedVirtualPathProvider; // initiaze HTTP-independent features HttpRuntime.InitializeHostingFeatures(hostingFlags, policyLevel, appDomainCreationException); // VSWhidbey 393259. Do not monitor idle timeout for CBM since Venus // will always restart a new appdomain if old one is shutdown. if (!BuildManagerHost.InClientBuildManager) { // start monitoring for idle inside app domain StartMonitoringForIdleTimeout(); } // notify app manager if the app domain limit is violated EnforceAppDomainLimit(); // get application identity (for explicit impersonation mode) GetApplicationIdentity(); // call AppInitialize, unless the flag says not to do it (e.g. CBM scenario). // Also, don't call it if HostingInit failed (VSWhidbey 210495) if(!HttpRuntime.HostingInitFailed) { try { BuildManager.ExecutePreAppStart(); if ((hostingFlags & HostingEnvironmentFlags.DontCallAppInitialize) == 0) { BuildManager.CallAppInitializeMethod(); } } catch (Exception e) { // could throw compilation errors in 'code' - report them with first http request HttpRuntime.InitializationException = e; if ((hostingFlags & HostingEnvironmentFlags.ThrowHostingInitErrors) != 0) { throw; } } } }
private ProcessHost(IProcessHostSupportFunctions functions) { try { // remember support functions _functions = functions; // pass them along to the HostingEnvironment in the default domain HostingEnvironment.SupportFunctions = functions; // create singleton app manager _appManager = ApplicationManager.GetApplicationManager(); // For M3 we get the throttling limit from the registry. // Dev10\Beta1 work item 543420 is to investigate whether we need to get rid of the throttling int maxPreloadConcurrency = (int)Misc.GetAspNetRegValue(null, "MaxPreloadConcurrency", 0); if (maxPreloadConcurrency > 0) { _preloadingThrottle = new System.Threading.Semaphore(maxPreloadConcurrency, maxPreloadConcurrency); } } catch (Exception e) { using (new ProcessImpersonationContext()) { Misc.ReportUnhandledException(e, new string[] { SR.GetString(SR.Cant_Create_Process_Host)}); Debug.Trace("internal", "ProcessHost::ctor failed with " + e.GetType().FullName + ": " + e.Message + "\r\n" + e.StackTrace); } throw; } }
internal CustomLoaderHelperFunctions(IProcessHostSupportFunctions supportFunctions, string appId) { _supportFunctions = supportFunctions; string appVirtualPath, appPhysicalPath, siteName, siteId; _supportFunctions.GetApplicationProperties(appId, out appVirtualPath, out appPhysicalPath, out siteName, out siteId); AppId = appId; AppVirtualPath = appVirtualPath; AppPhysicalPath = appPhysicalPath; }
internal void Initialize(ApplicationManager appManager, IApplicationHost appHost, IConfigMapPathFactory configMapPathFactory, HostingEnvironmentParameters hostingParameters, PolicyLevel policyLevel, Exception appDomainCreationException) { this._hostingParameters = hostingParameters; HostingEnvironmentFlags hostingFlags = HostingEnvironmentFlags.Default; if (this._hostingParameters != null) { hostingFlags = this._hostingParameters.HostingFlags; if (this._hostingParameters.IISExpressVersion != null) { ServerConfig.IISExpressVersion = this._hostingParameters.IISExpressVersion; } } if ((hostingFlags & HostingEnvironmentFlags.HideFromAppManager) == HostingEnvironmentFlags.Default) { this._appManager = appManager; } if ((hostingFlags & HostingEnvironmentFlags.ClientBuildManager) != HostingEnvironmentFlags.Default) { BuildManagerHost.InClientBuildManager = true; } if ((hostingFlags & HostingEnvironmentFlags.SupportsMultiTargeting) != HostingEnvironmentFlags.Default) { BuildManagerHost.SupportsMultiTargeting = true; } if ((appHost is ISAPIApplicationHost) && !ServerConfig.UseMetabase) { string str = ((ISAPIApplicationHost) appHost).ResolveRootWebConfigPath(); if (!string.IsNullOrEmpty(str)) { HttpConfigurationSystem.RootWebConfigurationFilePath = str; } IProcessHostSupportFunctions supportFunctions = ((ISAPIApplicationHost) appHost).SupportFunctions; if (supportFunctions != null) { _functions = Misc.CreateLocalSupportFunctions(supportFunctions); } } this._appId = HttpRuntime.AppDomainAppIdInternal; this._appVirtualPath = HttpRuntime.AppDomainAppVirtualPathObject; this._appPhysicalPath = HttpRuntime.AppDomainAppPathInternal; this._appHost = appHost; this._configMapPath = configMapPathFactory.Create(this._appVirtualPath.VirtualPathString, this._appPhysicalPath); HttpConfigurationSystem.EnsureInit(this._configMapPath, true, false); this._configMapPath2 = this._configMapPath as IConfigMapPath2; this._initiateShutdownWorkItemCallback = new WaitCallback(this.InitiateShutdownWorkItemCallback); if (this._appManager != null) { this._appManager.HostingEnvironmentActivated(CacheMemorySizePressure.EffectiveProcessMemoryLimit); } if (this._appHost == null) { this._appHost = new SimpleApplicationHost(this._appVirtualPath, this._appPhysicalPath); } else { this._externalAppHost = true; } this._configToken = this._appHost.GetConfigToken(); this._mapPathBasedVirtualPathProvider = new MapPathBasedVirtualPathProvider(); this._virtualPathProvider = this._mapPathBasedVirtualPathProvider; HttpRuntime.InitializeHostingFeatures(hostingFlags, policyLevel, appDomainCreationException); if (!BuildManagerHost.InClientBuildManager) { this.StartMonitoringForIdleTimeout(); } this.EnforceAppDomainLimit(); this.GetApplicationIdentity(); if (!HttpRuntime.HostingInitFailed) { try { BuildManager.CallPreStartInitMethods(); if ((hostingFlags & HostingEnvironmentFlags.DontCallAppInitialize) == HostingEnvironmentFlags.Default) { BuildManager.CallAppInitializeMethod(); } } catch (Exception exception) { HttpRuntime.InitializationException = exception; if ((hostingFlags & HostingEnvironmentFlags.ThrowHostingInitErrors) != HostingEnvironmentFlags.Default) { throw; } } } }
// called from ProcessHostFactoryHelper to get ProcessHost internal static ProcessHost GetProcessHost(IProcessHostSupportFunctions functions) { if (_theProcessHost == null) { lock (_processHostStaticLock) { if (_theProcessHost == null) { _theProcessHost = new ProcessHost(functions); } } } return _theProcessHost; }
public Object GetProcessHost(IProcessHostSupportFunctions functions) { return(default(Object)); }