private static void OnChanged(string key, object value, CacheItemRemovedReason reason)
{
// Only handle case when the dependency has changed.
if (reason != CacheItemRemovedReason.DependencyChanged)
{
return;
}
// Scan the app root for a webpages file
if (WebPagesDeployment.AppRootContainsWebPagesFile(_physicalFileSystem, HttpRuntime.AppDomainAppPath))
{
// Unload the app domain so we register plan9 when the app restarts
InfrastructureHelper.UnloadAppDomain();
}
else
{
// We need to re-register since the item was removed from the cache
RegisterForChangeNotifications();
}
}
/// <summary>
/// WebPages stores the version to be compiled against in AppSettings as >add key="webpages:version" value="1.0" /<.
/// Changing values AppSettings does not cause recompilation therefore we could run into a state where we have files compiled against v1 but the application is
/// currently v2.
/// </summary>
private static void InvalidateCompilationResultsIfVersionChanged(IBuildManager buildManager, IFileSystem fileSystem, string binDirectory, Version currentVersion)
{
Version previousVersion = WebPagesDeployment.GetPreviousRuntimeVersion(buildManager);
// Persist the current version number in BuildManager's cached file
WebPagesDeployment.PersistRuntimeVersion(buildManager, currentVersion);
if (previousVersion == null)
{
// Do nothing.
}
else if (previousVersion != currentVersion)
{
// If the previous runtime version is different, perturb the bin directory so that it forces recompilation.
WebPagesDeployment.ForceRecompile(fileSystem, binDirectory);
var httpCompileException = new HttpCompileException(ConfigurationResources.WebPagesVersionChanges);
// Indicator for tooling
httpCompileException.Data[ToolingIndicatorKey] = true;
throw httpCompileException;
}
}
// Adds Parameter for unit tests
internal static bool StartCore(IFileSystem fileSystem, string appDomainAppPath, string binDirectory, NameValueCollection appSettings, IEnumerable <AssemblyName> loadedAssemblies,
IBuildManager buildManager, Action <Version> loadWebPages, Action registerForChangeNotification, Func <string, AssemblyName> getAssemblyNameThunk = null)
{
if (WebPagesDeployment.IsExplicitlyDisabled(appSettings))
{
// If WebPages is explicitly disabled, exit.
Debug.WriteLine("WebPages Bootstrapper v{0}: not loading WebPages since it is disabled", AssemblyUtils.ThisAssemblyName.Version);
return(false);
}
Version maxWebPagesVersion = AssemblyUtils.GetMaxWebPagesVersion(loadedAssemblies);
Debug.Assert(maxWebPagesVersion != null, "Function must return some max value.");
if (AssemblyUtils.ThisAssemblyName.Version != maxWebPagesVersion)
{
// Always let the highest version determine what needs to be done. This would make future proofing simpler.
Debug.WriteLine("WebPages Bootstrapper v{0}: Higher version v{1} is available.", AssemblyUtils.ThisAssemblyName.Version, maxWebPagesVersion);
return(false);
}
var webPagesEnabled = WebPagesDeployment.IsEnabled(fileSystem, appDomainAppPath, appSettings);
Version binVersion = AssemblyUtils.GetVersionFromBin(binDirectory, fileSystem, getAssemblyNameThunk);
Version configVersion = WebPagesDeployment.GetVersionFromConfig(appSettings);
Version version = configVersion ?? binVersion ?? AssemblyUtils.WebPagesV1Version;
// Asserts to ensure unit tests are set up correctly. So essentially, we're unit testing the unit tests.
Debug.Assert(version != null, "GetVersion always returns a version");
Debug.Assert(binVersion == null || binVersion <= maxWebPagesVersion, "binVersion cannot be higher than max version");
if ((binVersion != null) && (binVersion != version))
{
// Determine if there's a version conflict. A conflict could occur if there's a version specified in the bin which is different from the version specified in the
// config that is different.
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, ConfigurationResources.WebPagesVersionConflict, version, binVersion));
}
else if (binVersion != null)
{
// The rest of the code is only meant to be executed if we are executing from the GAC.
// If a version is bin deployed, we don't need to do anything special to bootstrap.
return(false);
}
else if (!webPagesEnabled)
{
Debug.WriteLine("WebPages Bootstrapper v{0}: WebPages not enabled, registering for change notifications", AssemblyUtils.ThisAssemblyName.Version);
// Register for change notifications under the application root
registerForChangeNotification();
return(false);
}
else if (!AssemblyUtils.IsVersionAvailable(loadedAssemblies, version))
{
if (version == AssemblyUtils.WebPagesV1Version && configVersion == null && binVersion == null)
{
// No version was specified. We're implicitly assuming that the site is a v1 site. However, the user does not have V1 binaries available.
throw new InvalidOperationException(ConfigurationResources.WebPagesImplicitVersionFailure);
}
else
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, ConfigurationResources.WebPagesVersionNotFound, version, AssemblyUtils.ThisAssemblyName.Version));
}
}
Debug.WriteLine("WebPages Bootstrapper v{0}: loading version {1}, loading WebPages", AssemblyUtils.ThisAssemblyName.Version, version);
// If the version the application was compiled earlier was different, invalidate compilation results by adding a file to the bin.
InvalidateCompilationResultsIfVersionChanged(buildManager, fileSystem, binDirectory, version);
loadWebPages(version);
return(true);
}