internal override void CacheBuildResult(string cacheKey, BuildResult result, long hashCode, DateTime utcStart)
{
if (!(result is BuildResultCompiledTemplateType))
{
base.CacheBuildResult(cacheKey, result, hashCode, utcStart);
}
}
internal override void CacheBuildResult(string cacheKey, BuildResult result, long hashCode, DateTime utcStart)
{
if (!BuildResultCompiledType.UsesDelayLoadType(result))
{
ICollection virtualPathDependencies = result.VirtualPathDependencies;
CacheDependency dependencies = null;
if (virtualPathDependencies != null)
{
dependencies = result.VirtualPath.GetCacheDependency(virtualPathDependencies, utcStart);
if (dependencies != null)
{
result.UsesCacheDependency = true;
}
}
if (result.CacheToMemory)
{
CacheItemPriority normal;
BuildResultCompiledAssemblyBase base2 = result as BuildResultCompiledAssemblyBase;
if (((base2 != null) && (base2.ResultAssembly != null)) && !base2.UsesExistingAssembly)
{
string assemblyCacheKey = BuildResultCache.GetAssemblyCacheKey(base2.ResultAssembly);
Assembly assembly = (Assembly) this._cache.Get(assemblyCacheKey);
if (assembly == null)
{
this._cache.UtcInsert(assemblyCacheKey, base2.ResultAssembly, null, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null);
}
CacheDependency dependency2 = new CacheDependency(0, null, new string[] { assemblyCacheKey });
if (dependencies != null)
{
AggregateCacheDependency dependency3 = new AggregateCacheDependency();
dependency3.Add(new CacheDependency[] { dependencies, dependency2 });
dependencies = dependency3;
}
else
{
dependencies = dependency2;
}
}
string memoryCacheKey = GetMemoryCacheKey(cacheKey);
if (result.IsUnloadable)
{
normal = CacheItemPriority.Normal;
}
else
{
normal = CacheItemPriority.NotRemovable;
}
CacheItemRemovedCallback onRemoveCallback = null;
if (result.ShutdownAppDomainOnChange || (result is BuildResultCompiledAssemblyBase))
{
if (this._onRemoveCallback == null)
{
this._onRemoveCallback = new CacheItemRemovedCallback(this.OnCacheItemRemoved);
}
onRemoveCallback = this._onRemoveCallback;
}
this._cache.UtcInsert(memoryCacheKey, result, dependencies, result.MemoryCacheExpiration, result.MemoryCacheSlidingExpiration, normal, onRemoveCallback);
}
}
}
internal void SaveBuildResultToFile(string preservationFile, BuildResult result, long hashCode)
{
this._writer = new XmlTextWriter(preservationFile, Encoding.UTF8);
try
{
this._writer.Formatting = Formatting.Indented;
this._writer.Indentation = 4;
this._writer.WriteStartDocument();
this._writer.WriteStartElement("preserve");
this.SetAttribute("resultType", ((int) result.GetCode()).ToString(CultureInfo.InvariantCulture));
if (result.VirtualPath != null)
{
this.SetAttribute("virtualPath", result.VirtualPath.VirtualPathString);
}
this.SetAttribute("hash", result.ComputeHashCode(hashCode).ToString("x", CultureInfo.InvariantCulture));
string virtualPathDependenciesHash = result.VirtualPathDependenciesHash;
if (virtualPathDependenciesHash != null)
{
this.SetAttribute("filehash", virtualPathDependenciesHash);
}
result.SetPreservedAttributes(this);
this.SaveDependencies(result.VirtualPathDependencies);
this._writer.WriteEndElement();
this._writer.WriteEndDocument();
this._writer.Close();
}
catch
{
this._writer.Close();
File.Delete(preservationFile);
throw;
}
}
internal void SaveBuildResultToFile(string preservationFile,
BuildResult result, long hashCode) {
_writer = new XmlTextWriter(preservationFile, Encoding.UTF8);
try {
_writer.Formatting = Formatting.Indented;
_writer.Indentation = 4;
_writer.WriteStartDocument();
// <preserve assem="assemblyFile">
_writer.WriteStartElement("preserve");
// Save the type of BuildResult we're dealing with
Debug.Assert(result.GetCode() != BuildResultTypeCode.Invalid);
SetAttribute("resultType", ((int)result.GetCode()).ToString(CultureInfo.InvariantCulture));
// Save the virtual path for this BuildResult
if (result.VirtualPath != null)
SetAttribute("virtualPath", result.VirtualPath.VirtualPathString);
// Get the hash code of the BuildResult
long hash = result.ComputeHashCode(hashCode);
// The hash should always be valid if we got here.
Debug.Assert(hash != 0, "hash != 0");
// Save it to the preservation file
SetAttribute("hash", hash.ToString("x", CultureInfo.InvariantCulture));
// Can be null if that's what the VirtualPathProvider returns
string fileHash = result.VirtualPathDependenciesHash;
if (fileHash != null)
SetAttribute("filehash", fileHash);
result.SetPreservedAttributes(this);
SaveDependencies(result.VirtualPathDependencies);
// </preserve>
_writer.WriteEndElement();
_writer.WriteEndDocument();
_writer.Close();
}
catch {
// If an exception occurs during the writing of the xml file, clean it up
_writer.Close();
File.Delete(preservationFile);
throw;
}
}
internal override void CacheBuildResult(string cacheKey, BuildResult result, long hashCode, DateTime utcStart)
{
if (result.CacheToDisk)
{
if (HostingEnvironment.ShutdownInitiated)
{
BuildResultCompiledAssemblyBase base2 = result as BuildResultCompiledAssemblyBase;
if (base2 != null)
{
this.MarkAssemblyAndRelatedFilesForDeletion(base2.ResultAssembly.GetName().Name);
}
}
else
{
string preservedDataFileName = this.GetPreservedDataFileName(cacheKey);
new PreservationFileWriter(this.PrecompilationMode).SaveBuildResultToFile(preservedDataFileName, result, hashCode);
}
}
}
internal BuildDependencySet(BuildResult result) {
_result = result;
}
internal override void CacheBuildResult(string cacheKey, BuildResult result,
long hashCode, DateTime utcStart)
{
// Nothing to cache to disk if the app is already precompiled
}
static internal bool UsesDelayLoadType(BuildResult result) {
BuildResultCompiledType buildResultCompiledType = result as BuildResultCompiledType;
if (buildResultCompiledType != null) {
return buildResultCompiledType.IsDelayLoadType;
}
else {
return false;
}
}
internal override void CacheBuildResult(string cacheKey, BuildResult result,
long hashCode, DateTime utcStart)
{
ICollection virtualDependencies = result.VirtualPathDependencies;
Debug.Trace("BuildResultCache", "Adding cache " + cacheKey + " in the memory cache");
CacheDependency cacheDependency = null;
if (virtualDependencies != null)
{
cacheDependency = result.VirtualPath.GetCacheDependency(virtualDependencies, utcStart);
// If we got a cache dependency, remember that in the BuildResult
if (cacheDependency != null)
{
result.UsesCacheDependency = true;
}
}
// If it should not be cached to memory, leave it alone
if (!result.CacheToMemory)
{
return;
}
if (BuildResultCompiledType.UsesDelayLoadType(result))
{
// If the result is delaying loading of assembly, then don't cache
// to avoid having to load the assembly.
return;
}
BuildResultCompiledAssemblyBase compiledResult = result as BuildResultCompiledAssemblyBase;
if (compiledResult != null && compiledResult.ResultAssembly != null && !compiledResult.UsesExistingAssembly)
{
// Insert a new cache entry using the assembly path as the key
string assemblyKey = GetAssemblyCacheKey(compiledResult.ResultAssembly);
Assembly a = (Assembly)HttpRuntime.Cache.InternalCache.Get(assemblyKey);
if (a == null)
{
Debug.Trace("BuildResultCache", "Adding marker cache entry " + compiledResult.ResultAssembly);
// VSWhidbey 500049 - add as NotRemovable to prevent the assembly from being prematurely deleted
HttpRuntime.Cache.InternalCache.Insert(assemblyKey, compiledResult.ResultAssembly, null);
}
else
{
Debug.Assert(a == compiledResult.ResultAssembly);
}
// Now create a dependency based on that key. This way, by removing that key, we are able to
// remove all the pages that live in that assembly from the cache.
CacheDependency assemblyCacheDependency = new CacheDependency(0, null, new string[] { assemblyKey });
if (cacheDependency != null)
{
// We can't share the same CacheDependency, since we don't want the UtcStart
// behavior for the assembly. Use an Aggregate to put the two together.
AggregateCacheDependency tmpDependency = new AggregateCacheDependency();
tmpDependency.Add(new CacheDependency[] { cacheDependency, assemblyCacheDependency });
cacheDependency = tmpDependency;
}
else
{
cacheDependency = assemblyCacheDependency;
}
}
string key = GetMemoryCacheKey(cacheKey);
// Only allow the cache item to expire if the result can be unloaded. Otherwise,
// we may as well cache it forever (e.g. for Assemblies and Types).
CacheItemPriority cachePriority;
if (result.IsUnloadable)
{
cachePriority = CacheItemPriority.Default;
}
else
{
cachePriority = CacheItemPriority.NotRemovable;
}
CacheItemRemovedCallback onRemoveCallback = null;
// If the appdomain needs to be shut down when the item becomes invalid, register
// a callback to do the shutdown.
if (result.ShutdownAppDomainOnChange || result is BuildResultCompiledAssemblyBase)
{
// Create the delegate on demand
if (_onRemoveCallback == null)
{
_onRemoveCallback = new CacheItemRemovedCallback(OnCacheItemRemoved);
}
onRemoveCallback = _onRemoveCallback;
}
HttpRuntime.Cache.InternalCache.Insert(key, result, new CacheInsertOptions()
{
Dependencies = cacheDependency,
AbsoluteExpiration = result.MemoryCacheExpiration,
SlidingExpiration = result.MemoryCacheSlidingExpiration,
Priority = cachePriority,
OnRemovedCallback = onRemoveCallback
});
}
internal abstract void CacheBuildResult(string cacheKey, BuildResult result,
long hashCode, DateTime utcStart);
internal void CacheBuildResult(string cacheKey, BuildResult result, DateTime utcStart) {
CacheBuildResult(cacheKey, result, 0 /*hashCode*/, utcStart);
}
internal abstract void CacheBuildResult(string cacheKey, BuildResult result,
long hashCode, DateTime utcStart);
internal void SetBuildResultDependencies(BuildResult result)
{
result.AddVirtualPathDependencies(this.VirtualPathDependencies);
}
internal static bool UsesDelayLoadType(BuildResult result)
{
BuildResultCompiledType type = result as BuildResultCompiledType;
return ((type != null) && type.IsDelayLoadType);
}
internal BuildDependencySet(BuildResult result)
{
this._result = result;
}
private BuildResult ReadFileInternal(VirtualPath virtualPath, string preservationFile, long hashCode, bool ensureIsUpToDate)
{
XmlDocument doc = new XmlDocument();
doc.Load(preservationFile);
// Get the root element, and make sure it's what we expect
_root = doc.DocumentElement;
Debug.Assert(_root != null && _root.Name == "preserve", "_root != null && _root.Name == \"preserve\"");
if (_root == null || _root.Name != "preserve")
{
return(null);
}
// Get the type of the BuildResult preserved in this file
string resultTypeCodeString = GetAttribute("resultType");
BuildResultTypeCode resultTypeCode = (BuildResultTypeCode)Int32.Parse(
resultTypeCodeString, CultureInfo.InvariantCulture);
// Get the config path that affects this BuildResult if one wasn't passed in.
// Note that the passed in path may be different with Sharepoint-like ghosting (VSWhidbey 343230)
if (virtualPath == null)
{
virtualPath = VirtualPath.Create(GetAttribute("virtualPath"));
}
long savedHash = 0;
string savedFileHash = null;
// Ignore dependencies in precompilation mode
if (!_precompilationMode)
{
// Read the saved hash from the preservation file
string hashString = GetAttribute("hash");
Debug.Assert(hashString != null, "hashString != null");
if (hashString == null)
{
return(null);
}
// Parse the saved hash string as an hex int
savedHash = Int64.Parse(hashString, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
// Read the saved file hash from the preservation file. This is the hash the represents
// the state of all the virtual files that the build result depends on.
savedFileHash = GetAttribute("filehash");
}
// Create the BuildResult accordingly
BuildResult result = BuildResult.CreateBuildResultFromCode(resultTypeCode, virtualPath);
// Ignore dependencies in precompilation mode
if (!_precompilationMode)
{
ReadDependencies();
if (_sourceDependencies != null)
{
result.SetVirtualPathDependencies(_sourceDependencies);
}
result.VirtualPathDependenciesHash = savedFileHash;
// Check if the build result is up to date
bool outOfDate = false;
if (!result.IsUpToDate(virtualPath, ensureIsUpToDate))
{
Debug.Trace("PreservationFileReader", Path.GetFileName(preservationFile) +
" is out of date (IsUpToDate==false)");
outOfDate = true;
}
else
{
// The virtual paths hash code was up to date, so check the
// other hash code.
// Get the current hash code
long currentHash = result.ComputeHashCode(hashCode);
// If the hash doesn't match, the preserved data is out of date
if (currentHash == 0 || currentHash != savedHash)
{
outOfDate = true;
Debug.Trace("PreservationFileReader", Path.GetFileName(preservationFile) +
" is out of date (ComputeHashCode)");
}
}
if (outOfDate)
{
bool gotLock = false;
try {
// We need to delete the preservation file together with the assemblies/pdbs
// under the same lock so to avoid bad interleaving where one process
// deletes the .compiled file that another process just created, orphaning
// the files generated by the other process.
// (Dev10
CompilationLock.GetLock(ref gotLock);
// Give the BuildResult a chance to do some cleanup
result.RemoveOutOfDateResources(this);
// The preservation file is not useable, so delete it
File.Delete(preservationFile);
}
finally {
// Always release the mutex if we had taken it
if (gotLock)
{
CompilationLock.ReleaseLock();
}
}
return(null);
}
}
// Ask the BuildResult to read the data it needs
result.GetPreservedAttributes(this);
return(result);
}
private void AddBuildProviders(bool retryIfDeletionHappens)
{
DiskBuildResultCache.ResetAssemblyDeleted();
foreach (VirtualFile vfile in _vdir.Files)
{
// If it's already built and up to date, skip it
BuildResult result = null;
try {
result = BuildManager.GetVPathBuildResultFromCache(vfile.VirtualPathObject);
}
catch {
// Ignore the cached error in batch compilation mode, since we want to compile
// as many files as possible.
// But don't ignore it in CBM or precompile cases, since we always want to try
// to compile everything that had failed before.
if (!BuildManager.PerformingPrecompilation)
{
// Skip it if an exception occurs (e.g. if a compile error was cached for it)
continue;
}
}
if (result != null)
{
continue;
}
BuildProvider buildProvider = BuildManager.CreateBuildProvider(vfile.VirtualPathObject,
_compConfig, _referencedAssemblies, false /*failIfUnknown*/);
// Non-supported file type
if (buildProvider == null)
{
continue;
}
// IgnoreFileBuildProvider's should never be created
Debug.Assert(!(buildProvider is IgnoreFileBuildProvider));
_buildProviders[vfile.VirtualPath] = buildProvider;
}
// If an assembly had to be deleted/renamed as a result of calling GetVPathBuildResultFromCache,
// me way need to run the AddBuildProviders logic again. The reason is that as a result of
// deleting the assembly, we may have invalidated other BuildResult that we had earlier found
// to be up to date (VSWhidbey 269297)
if (DiskBuildResultCache.InUseAssemblyWasDeleted)
{
Debug.Assert(retryIfDeletionHappens);
// Only retry if we're doing precompilation. For standard batching, we can live
// with the fact that not everything will be built after we're done (and we want to
// be done as quickly as possible since the user is waiting).
if (retryIfDeletionHappens && BuildManager.PerformingPrecompilation)
{
Debug.Trace("WebDirectoryBatchCompiler", "Rerunning AddBuildProviders for '" +
_vdir.VirtualPath + "' because an assembly was out of date.");
// Pass false for retryIfDeletionHappens to make sure we don't get in an
// infinite recursion.
AddBuildProviders(false /*retryIfDeletionHappens*/);
}
}
}
internal static bool UsesDelayLoadType(BuildResult result)
{
BuildResultCompiledType type = result as BuildResultCompiledType;
return((type != null) && type.IsDelayLoadType);
}
internal void CacheBuildResult(string cacheKey, BuildResult result, DateTime utcStart)
{
this.CacheBuildResult(cacheKey, result, 0L, utcStart);
}
internal override void CacheBuildResult(string cacheKey, BuildResult result,
long hashCode, DateTime utcStart) {
// Nothing to cache to disk if the app is already precompiled
}
internal override void CacheBuildResult(string cacheKey, BuildResult result, long hashCode, DateTime utcStart)
{
}
internal override void CacheBuildResult(string cacheKey, BuildResult result,
long hashCode, DateTime utcStart) {
ICollection virtualDependencies = result.VirtualPathDependencies;
Debug.Trace("BuildResultCache", "Adding cache " + cacheKey + " in the memory cache");
CacheDependency cacheDependency = null;
if (virtualDependencies != null) {
cacheDependency = result.VirtualPath.GetCacheDependency(virtualDependencies, utcStart);
// If we got a cache dependency, remember that in the BuildResult
if (cacheDependency != null)
result.UsesCacheDependency = true;
}
// If it should not be cached to memory, leave it alone
if (!result.CacheToMemory) {
return;
}
if (BuildResultCompiledType.UsesDelayLoadType(result)) {
// If the result is delaying loading of assembly, then don't cache
// to avoid having to load the assembly.
return;
}
BuildResultCompiledAssemblyBase compiledResult = result as BuildResultCompiledAssemblyBase;
if (compiledResult != null && compiledResult.ResultAssembly != null && !compiledResult.UsesExistingAssembly) {
// Insert a new cache entry using the assembly path as the key
string assemblyKey = GetAssemblyCacheKey(compiledResult.ResultAssembly);
Assembly a = (Assembly)_cache.Get(assemblyKey);
if (a == null) {
Debug.Trace("BuildResultCache", "Adding marker cache entry " + compiledResult.ResultAssembly);
// VSWhidbey 500049 - add as NotRemovable to prevent the assembly from being prematurely deleted
_cache.UtcInsert(assemblyKey, compiledResult.ResultAssembly,
null,
Cache.NoAbsoluteExpiration,
Cache.NoSlidingExpiration,
CacheItemPriority.NotRemovable,
null);
}
else {
Debug.Assert(a == compiledResult.ResultAssembly);
}
// Now create a dependency based on that key. This way, by removing that key, we are able to
// remove all the pages that live in that assembly from the cache.
CacheDependency assemblyCacheDependency = new CacheDependency(0, null, new string[] { assemblyKey });
if (cacheDependency != null) {
// We can't share the same CacheDependency, since we don't want the UtcStart
// behavior for the assembly. Use an Aggregate to put the two together.
AggregateCacheDependency tmpDependency = new AggregateCacheDependency();
tmpDependency.Add(new CacheDependency[] { cacheDependency, assemblyCacheDependency });
cacheDependency = tmpDependency;
}
else {
cacheDependency = assemblyCacheDependency;
}
}
string key = GetMemoryCacheKey(cacheKey);
// Only allow the cache item to expire if the result can be unloaded. Otherwise,
// we may as well cache it forever (e.g. for Assemblies and Types).
CacheItemPriority cachePriority;
if (result.IsUnloadable)
cachePriority = CacheItemPriority.Default;
else
cachePriority = CacheItemPriority.NotRemovable;
CacheItemRemovedCallback onRemoveCallback = null;
// If the appdomain needs to be shut down when the item becomes invalid, register
// a callback to do the shutdown.
if (result.ShutdownAppDomainOnChange || result is BuildResultCompiledAssemblyBase) {
// Create the delegate on demand
if (_onRemoveCallback == null)
_onRemoveCallback = new CacheItemRemovedCallback(OnCacheItemRemoved);
onRemoveCallback = _onRemoveCallback;
}
_cache.UtcInsert(key, result, cacheDependency,
result.MemoryCacheExpiration,
result.MemoryCacheSlidingExpiration,
cachePriority,
onRemoveCallback);
}
private BuildResult PostProcessFoundBuildResult(BuildResult result, bool keyFromVPP, VirtualPath virtualPath) {
// Check that the virtual path in the result matches the passed in
// virtualPath (VSWhidbey 516641). But skip this check in case the key came from
// calling VirtualPathProvider.GetCacheKey, as it may legitimately not match.
if (!keyFromVPP) {
if (virtualPath != null && virtualPath != result.VirtualPath) {
Debug.Assert(false);
return null;
}
}
// If what we found in the cache is a CompileError, rethrow the exception
if (result is BuildResultCompileError) {
// Report the cached error from Callback interface.
HttpCompileException compileException = ((BuildResultCompileError)result).CompileException;
// But don't report it if we're doing precompilation, as that would cause it to be
// reported twice because we always try to compile everything that has failed
// before (VSWhidbey 525414)
if (!PerformingPrecompilation) {
ReportErrorsFromException(compileException);
}
throw compileException;
}
return result;
}
internal override void CacheBuildResult(string cacheKey, BuildResult result,
long hashCode, DateTime utcStart) {
// If it should not be cached to disk, leave it alone
if (!result.CacheToDisk)
return;
// VSWhidbey 564168 don't save to disk if already shutting down, otherwise we might
// be persisting assembly that was compiled with obsolete references.
// Since we are shutting down and not creating any cache, delete the compiled result
// as it will not be used in future.
if (HostingEnvironment.ShutdownInitiated) {
BuildResultCompiledAssemblyBase compiledResult = result as BuildResultCompiledAssemblyBase;
if (compiledResult != null)
MarkAssemblyAndRelatedFilesForDeletion(compiledResult.ResultAssembly.GetName().Name);
return;
}
string preservationFile = GetPreservedDataFileName(cacheKey);
PreservationFileWriter pfw = new PreservationFileWriter(PrecompilationMode);
pfw.SaveBuildResultToFile(preservationFile, result, hashCode);
}
private bool CacheVPathBuildResultInternal(VirtualPath virtualPath,
BuildResult result, DateTime utcStart) {
string cacheKey = GetCacheKeyFromVirtualPath(virtualPath);
return CacheBuildResult(cacheKey, result, utcStart);
}
internal override void CacheBuildResult(string cacheKey, BuildResult result,
long hashCode, DateTime utcStart) {
// Don't create preservation files in bin for pages in the updatable model,
// because we turn them into a v1 style code behind, which works as a result of
// having the aspx file point to the bin class via an inherits attribute.
if (result is BuildResultCompiledTemplateType)
return;
base.CacheBuildResult(cacheKey, result, hashCode, utcStart);
}
private bool CacheBuildResultInternal(string cacheKey, BuildResult result,
long hashCode, DateTime utcStart) {
// Before caching it, make sure the hash has been computed
result.EnsureVirtualPathDependenciesHashComputed();
for (int i = 0; i < _caches.Length; i++) {
_caches[i].CacheBuildResult(cacheKey, result, hashCode, utcStart);
}
// If we find that it's no longer valid after caching it, remove it from the cache (VSWhidbey 578372)
if (!TimeStampChecker.CheckFilesStillValid(cacheKey, result.VirtualPathDependencies)) {
_memoryCache.RemoveAssemblyAndCleanupDependencies(result as BuildResultCompiledAssemblyBase);
return false;
}
return true;
}
[global::Umbraco.Web.WebApi.UmbracoAuthorize] // can use Umbraco's
public HttpResponseMessage BuildModels()
{
try
{
// the UmbracoAuthorize attribute validates the current user
// the UmbracoAuthorizedApiController would in addition check for .Disabled and .NoConsole
// but to do it it relies on internal methods so we have to do it here explicitely
// was doing it using legacy User class, now using new API class
//var user = umbraco.BusinessLogic.User.GetCurrent();
var user = UmbracoContext.Security.CurrentUser;
//if (user.Disabled || user.NoConsole)
if (!user.IsApproved && user.IsLockedOut)
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
//if (user.Applications.All(x => x.alias != "developer"))
if (!user.AllowedSections.Contains("developer"))
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
if (!Config.EnableAppDataModels && !Config.EnableAppCodeModels && !Config.EnableDllModels)
{
var result2 = new BuildResult { Success = false, Message = "Models generation is not enabled." };
return Request.CreateResponse(HttpStatusCode.OK, result2, Configuration.Formatters.JsonFormatter);
}
var appData = HostingEnvironment.MapPath("~/App_Data");
if (appData == null)
throw new Exception("Panic: appData is null.");
var appCode = HostingEnvironment.MapPath("~/App_Code");
if (appCode == null)
throw new Exception("Panic: appCode is null.");
var bin = HostingEnvironment.MapPath("~/bin");
if (bin== null)
throw new Exception("Panic: bin is null.");
// EnableDllModels will recycle the app domain - but this request will end properly
GenerateModels(appData, Config.EnableDllModels ? bin : null);
// will recycle the app domain - but this request will end properly
if (Config.EnableAppCodeModels)
TouchModelsFile(appCode);
var result = new BuildResult {Success = true};
return Request.CreateResponse(HttpStatusCode.OK, result, Configuration.Formatters.JsonFormatter);
}
catch (Exception e)
{
var message = string.Format("{0}: {1}\r\n{2}", e.GetType().FullName, e.Message, e.StackTrace);
var result = new BuildResult { Success = false, Message = message };
return Request.CreateResponse(HttpStatusCode.OK, result, Configuration.Formatters.JsonFormatter);
}
}
internal void CacheBuildResult(string cacheKey, BuildResult result, DateTime utcStart)
{
CacheBuildResult(cacheKey, result, 0 /*hashCode*/, utcStart);
}
internal static bool CacheVPathBuildResult(VirtualPath virtualPath,
BuildResult result, DateTime utcStart) {
return _theBuildManager.CacheVPathBuildResultInternal(virtualPath, result, utcStart);
}
internal void SetBuildResultDependencies(BuildResult result) {
result.AddVirtualPathDependencies(VirtualPathDependencies);
}
internal static bool CacheBuildResult(string cacheKey, BuildResult result, DateTime utcStart) {
return _theBuildManager.CacheBuildResultInternal(cacheKey, result, 0 /*hashCode*/, utcStart);
}
internal void CacheBuildResult(string cacheKey, BuildResult result, DateTime utcStart)
{
this.CacheBuildResult(cacheKey, result, 0L, utcStart);
}
/*
* Add a BuildResult's source dependencies to our own source dependencies
*/
internal void AddBuildResultDependency(BuildResult result) {
// Add one direct dependency
if (_pageParserFilter != null)
_pageParserFilter.OnDirectDependencyAdded();
if (result.VirtualPathDependencies == null)
return;
foreach (string virtualPath in result.VirtualPathDependencies) {
// Add one dependency for each file (to include direct and indirect)
if (_pageParserFilter != null)
_pageParserFilter.OnDependencyAdded();
AddSourceDependency2(VirtualPath.Create(virtualPath));
}
}
internal static Assembly GetCodeDirectoryAssembly(VirtualPath virtualDir,
CodeDirectoryType dirType, string assemblyName,
StringSet excludedSubdirectories, bool isDirectoryAllowed)
{
string physicalDir = virtualDir.MapPath();
if (!isDirectoryAllowed)
{
// The directory should never exist in a precompiled app
if (Directory.Exists(physicalDir))
{
throw new HttpException(SR.GetString(SR.Bar_dir_in_precompiled_app, virtualDir));
}
}
bool supportLocalization = IsResourceCodeDirectoryType(dirType);
// Determine the proper cache key based on the type of directory we're processing
string cacheKey = assemblyName;
// Try the cache first
BuildResult result = BuildManager.GetBuildResultFromCache(cacheKey);
Assembly resultAssembly = null;
// If it's cached, just return it
if (result != null)
{
// It should always be a BuildResultCompiledAssembly, though if there is
// a VirtualPathProvider doing very bad things, it may not (VSWhidbey 341701)
Debug.Assert(result is BuildResultCompiledAssembly);
if (result is BuildResultCompiledAssembly)
{
// If it's the main code assembly, keep track of it so we can later call
// the AppInitialize method
if (result is BuildResultMainCodeAssembly)
{
Debug.Assert(dirType == CodeDirectoryType.MainCode);
Debug.Assert(_mainCodeBuildResult == null);
_mainCodeBuildResult = (BuildResultMainCodeAssembly)result;
}
resultAssembly = ((BuildResultCompiledAssembly)result).ResultAssembly;
if (!supportLocalization)
{
return(resultAssembly);
}
// We found a preserved resource assembly. However, we may not be done,
// as the culture specific files may have changed.
// But don't make any further checks if the directory is not allowed (precomp secenario).
// In that case, we should always return the assembly (VSWhidbey 533498)
if (!isDirectoryAllowed)
{
return(resultAssembly);
}
BuildResultResourceAssembly buildResultResAssembly = (BuildResultResourceAssembly)result;
string newResourcesDependenciesHash = HashCodeCombiner.GetDirectoryHash(virtualDir);
// If the resources hash (which includes satellites) is up to date, we're done
if (newResourcesDependenciesHash == buildResultResAssembly.ResourcesDependenciesHash)
{
return(resultAssembly);
}
}
}
// If app was precompiled, don't attempt compilation
if (!isDirectoryAllowed)
{
return(null);
}
// Check whether the virtual dir is mapped to a different application,
// which we don't support (VSWhidbey 218603). But don't do this for LocalResource (VSWhidbey 237935)
if (dirType != CodeDirectoryType.LocalResources && !StringUtil.StringStartsWithIgnoreCase(physicalDir, HttpRuntime.AppDomainAppPathInternal))
{
throw new HttpException(SR.GetString(SR.Virtual_codedir, virtualDir.VirtualPathString));
}
// If the directory doesn't exist, we may be done
if (!Directory.Exists(physicalDir))
{
// We're definitely done if it's not the main code dir
if (dirType != CodeDirectoryType.MainCode)
{
return(null);
}
// If it is the main code dir, we're only done is there is no profile to compile
// since the profice gets built as part of the main assembly.
if (!ProfileBuildProvider.HasCompilableProfile)
{
return(null);
}
}
// Otherwise, compile it
BuildManager.ReportDirectoryCompilationProgress(virtualDir);
DateTime utcStart = DateTime.UtcNow;
CodeDirectoryCompiler cdc = new CodeDirectoryCompiler(virtualDir,
dirType, excludedSubdirectories);
string outputAssemblyName = null;
if (resultAssembly != null)
{
// If resultAssembly is not null, we are in the case where we just need to build
// the localized resx file in a resources dir (local or global)
Debug.Assert(supportLocalization);
outputAssemblyName = resultAssembly.GetName().Name;
cdc._onlyBuildLocalizedResources = true;
}
else
{
outputAssemblyName = BuildManager.GenerateRandomAssemblyName(assemblyName);
}
BuildProvidersCompiler bpc =
new BuildProvidersCompiler(virtualDir, supportLocalization, outputAssemblyName);
cdc._bpc = bpc;
// Find all the build provider we want to compile from the code directory
cdc.FindBuildProviders();
// Give them to the BuildProvidersCompiler
bpc.SetBuildProviders(cdc._buildProviders);
// Compile them into an assembly
CompilerResults results = bpc.PerformBuild();
// Did we just compile something?
if (results != null)
{
Debug.Assert(result == null);
Debug.Assert(resultAssembly == null);
// If there is already a loaded module with the same path, try to wait for it to be unloaded.
// Otherwise, we would end up loading this old assembly instead of the new one (VSWhidbey 554697)
DateTime waitLimit = DateTime.UtcNow.AddMilliseconds(3000);
for (;;)
{
IntPtr hModule = UnsafeNativeMethods.GetModuleHandle(results.PathToAssembly);
if (hModule == IntPtr.Zero)
{
break;
}
Debug.Trace("CodeDirectoryCompiler", results.PathToAssembly + " is already loaded. Waiting a bit");
System.Threading.Thread.Sleep(250);
// Stop trying if the timeout was reached
if (DateTime.UtcNow > waitLimit)
{
Debug.Trace("CodeDirectoryCompiler", "Timeout waiting for old assembly to unload: " + results.PathToAssembly);
throw new HttpException(SR.GetString(SR.Assembly_already_loaded, results.PathToAssembly));
}
}
resultAssembly = results.CompiledAssembly;
}
// It is possible that there was nothing to compile (and we're not in the
// satellite resources case)
if (resultAssembly == null)
{
return(null);
}
// For the main code directory, use a special BuildResult that takes care of
// calling AppInitialize if it finds one
if (dirType == CodeDirectoryType.MainCode)
{
// Keep track of it so we can later call the AppInitialize method
_mainCodeBuildResult = new BuildResultMainCodeAssembly(resultAssembly);
result = _mainCodeBuildResult;
}
else if (supportLocalization)
{
result = new BuildResultResourceAssembly(resultAssembly);
}
else
{
result = new BuildResultCompiledAssembly(resultAssembly);
}
result.VirtualPath = virtualDir;
// If compilations are optimized, we need to include the right dependencies, since we can no longer
// rely on everything getting wiped out when something in App_Code changes.
// But don't do this for local resources, since they have their own special way of
// dealing with dependencies (in BuildResultResourceAssembly.ComputeSourceDependenciesHashCode).
// It's crucial *not* to do it as it triggers a tricky infinite recursion due to the fact
// that GetBuildResultFromCacheInternal calls EnsureFirstTimeDirectoryInitForDependencies if
// there is at least one dependency
if (BuildManager.OptimizeCompilations && dirType != CodeDirectoryType.LocalResources)
{
result.AddVirtualPathDependencies(new SingleObjectCollection(virtualDir.AppRelativeVirtualPathString));
}
// Top level assembly should not be cached to memory. But LocalResources are *not*
// top level files, and do benefit from memory caching
if (dirType != CodeDirectoryType.LocalResources)
{
result.CacheToMemory = false;
}
// Cache it for next time
BuildManager.CacheBuildResult(cacheKey, result, utcStart);
return(resultAssembly);
}
