internal void RemoveAllCodegenFiles() { this.RemoveCodegenResourceDir(); foreach (FileData data in (IEnumerable)FileEnumerator.Create(base._cacheDir)) { if (data.IsDirectory) { if (((data.Name != "assembly") && (data.Name != "hash")) && !StringUtil.StringStartsWith(data.Name, "Sources_")) { try { this.DeleteFilesInDirectory(data.FullName); } catch { } } } else { DiskBuildResultCache.TryDeleteFile(data.FullName); } } AppDomainSetup setupInformation = Thread.GetDomain().SetupInformation; UnsafeNativeMethods.DeleteShadowCache(setupInformation.CachePath, setupInformation.ApplicationName); }
private void AddBuildProviders(bool retryIfDeletionHappens) { DiskBuildResultCache.ResetAssemblyDeleted(); foreach (VirtualFile file in this._vdir.Files) { BuildResult vPathBuildResultFromCache = null; try { vPathBuildResultFromCache = BuildManager.GetVPathBuildResultFromCache(file.VirtualPathObject); } catch { if (!BuildManager.PerformingPrecompilation) { continue; } } if (vPathBuildResultFromCache == null) { System.Web.Compilation.BuildProvider provider = BuildManager.CreateBuildProvider(file.VirtualPathObject, this._compConfig, this._referencedAssemblies, false); if (provider != null) { this._buildProviders[file.VirtualPath] = provider; } } } if ((DiskBuildResultCache.InUseAssemblyWasDeleted && retryIfDeletionHappens) && BuildManager.PerformingPrecompilation) { this.AddBuildProviders(false); } }
internal void RemoveAllCodegenFiles() { Debug.Trace("BuildResultCache", "Deleting all files from " + _cacheDir); RemoveCodegenResourceDir(); // Remove everything in the codegen directory, as well as all the subdirectories // used for culture assemblies // Go through all the files in the codegen dir. Delete everything, except // for the fusion cache, which is in the "assembly" subdirectory foreach (FileData fileData in FileEnumerator.Create(_cacheDir)) { // If it's a directories if (fileData.IsDirectory) { // Skip the fusion cache if (fileData.Name == fusionCacheDirectoryName) { continue; } // Skip the "hash" folder if (fileData.Name == webHashDirectoryName) { continue; } // Skip the source files generated for the designer (VSWhidbey 138194) if (StringUtil.StringStartsWith(fileData.Name, CodeDirectoryCompiler.sourcesDirectoryPrefix)) { continue; } try { // If it is a directory, only remove the files inside and not the directory itself // VSWhidbey 596757 DeleteFilesInDirectory(fileData.FullName); } catch { } // Ignore all exceptions continue; } // VSWhidbey 564168 Do not delete files that cannot be deleted, these files are still // referenced by other appdomains that are in the process of shutting down. // We also do not rename as renaming can cause an assembly not to be found if another // appdomain tries to compile against it. DiskBuildResultCache.TryDeleteFile(fileData.FullName); } // Clean up the fusion shadow copy cache AppDomainSetup appDomainSetup = Thread.GetDomain().SetupInformation; UnsafeNativeMethods.DeleteShadowCache(appDomainSetup.CachePath, appDomainSetup.ApplicationName); }
private static bool AssemblyIsInvalid(Assembly a) { string assemblyCodeBase = Util.GetAssemblyCodeBase(a); if (FileUtil.FileExists(assemblyCodeBase)) { return(DiskBuildResultCache.HasDotDeleteFile(assemblyCodeBase)); } return(true); }
private static void RemoveAssembly(string path) { FileInfo f = new FileInfo(path); DiskBuildResultCache.RemoveAssembly(f); string str = Path.ChangeExtension(f.FullName, ".pdb"); if (File.Exists(str)) { DiskBuildResultCache.TryDeleteFile(new FileInfo(str)); } }
internal void RemoveOldTempFiles() { this.RemoveCodegenResourceDir(); string path = base._cacheDir + @"\"; foreach (FileData data in (IEnumerable)FileEnumerator.Create(path)) { if (!data.IsDirectory) { string extension = Path.GetExtension(data.Name); switch (extension) { case ".dll": case ".pdb": case ".web": case ".ccu": case ".compiled": { continue; } } if (extension != ".delete") { int length = data.Name.LastIndexOf('.'); if (length <= 0) { goto Label_013A; } string str3 = data.Name.Substring(0, length); int index = str3.IndexOf('.'); int num3 = str3.LastIndexOf('.'); if ((num3 > 0) && (index != num3)) { str3 = str3.Substring(0, num3); } if (!FileUtil.FileExists(path + str3 + ".dll") && !FileUtil.FileExists(path + "App_Web_" + str3 + ".dll")) { goto Label_013A; } } else { DiskBuildResultCache.CheckAndRemoveDotDeleteFile(new FileInfo(data.FullName)); } } continue; Label_013A: Util.DeleteFileNoException(data.FullName); } }
private static void RemoveAssembly(string path) { var f = new FileInfo(path); DiskBuildResultCache.RemoveAssembly(f); // Delete the associated pdb file as well, since it is possible to // run into a situation where the dependency has changed just // when the cache item is about to get inserted, resulting in // the callback deleting only the dll file and leaving behind the // pdb file. (Dev10 bug 846606) var pdbPath = Path.ChangeExtension(f.FullName, ".pdb"); if (File.Exists(pdbPath)) { DiskBuildResultCache.TryDeleteFile(new FileInfo(pdbPath)); } }
private void InvalidateInvalidAssembly(CompilerResults results, CompilerParameters compilParams) { if ((results != null) && results.Errors.HasErrors) { foreach (CompilerError error in results.Errors) { if (!error.IsWarning && System.Web.Util.StringUtil.EqualsIgnoreCase(error.ErrorNumber, "CS0016")) { if (this.CultureName != null) { DiskBuildResultCache.TryDeleteFile(new FileInfo(Path.Combine(this._tempFiles.TempDir, this.OutputAssemblyName + ".dll"))); } DiskBuildResultCache.TryDeleteFile(compilParams.OutputAssembly); } } } }
private void RemoveAssemblyAndCleanupDependencies(string assemblyName) { bool gotLock = false; try { CompilationLock.GetLock(ref gotLock); lock (this._dependentAssemblies) { this.RemoveAssemblyAndCleanupDependenciesNoLock(assemblyName); } } finally { if (gotLock) { CompilationLock.ReleaseLock(); } DiskBuildResultCache.ShutDownAppDomainIfRequired(); } }
private void RemoveAssemblyAndCleanupDependencies(string assemblyName) { bool gotLock = false; try { // Grab the compilation mutex, since we will remove cached build result CompilationLock.GetLock(ref gotLock); // Protect the dependent assemblies table, as it's accessed/modified in the recursion lock (_dependentAssemblies) { RemoveAssemblyAndCleanupDependenciesNoLock(assemblyName); } } finally { // Always release the mutex if we had taken it if (gotLock) { CompilationLock.ReleaseLock(); } DiskBuildResultCache.ShutDownAppDomainIfRequired(); } }
internal PreservationFileReader(DiskBuildResultCache diskCache, bool precompilationMode) { _diskCache = diskCache; _precompilationMode = precompilationMode; }
/* * Delete all temporary files from the codegen directory (e.g. source files, ...) */ internal void RemoveOldTempFiles() { Debug.Trace("BuildResultCache", "Deleting old temporary files from " + _cacheDir); RemoveCodegenResourceDir(); string codegen = _cacheDir + "\\"; // Go through all the files in the codegen dir foreach (FileData fileData in FileEnumerator.Create(codegen)) { // Skip directories if (fileData.IsDirectory) { continue; } // If it has a known extension, skip it string ext = Path.GetExtension(fileData.Name); if (ext == ".dll" || ext == ".pdb" || ext == ".web" || ext == ".ccu" || ext == ".prof" || ext == preservationFileExtension) { continue; } // .delete files need to be removed. if (ext != dotDelete) { // Don't delete the temp file if it's named after a dll that's still around // since it could still be useful for debugging. // Note that we can't use GetFileNameWithoutExtension here because // some of the files are named 5hvoxl6v.0.cs, and it would return // 5hvoxl6v.0 instead of just 5hvoxl6v int periodIndex = fileData.Name.LastIndexOf('.'); if (periodIndex > 0) { string baseName = fileData.Name.Substring(0, periodIndex); int secondPeriodIndex = baseName.LastIndexOf('.'); if (secondPeriodIndex > 0) { baseName = baseName.Substring(0, secondPeriodIndex); } // Generated source files uses assemblyname as prefix so we should keep them. if (FileUtil.FileExists(codegen + baseName + ".dll")) { continue; } // other generated files, such as .cmdline, .err and .out need to add the // WebAssemblyNamePrefix, since they do not use the assembly name as prefix. if (FileUtil.FileExists(codegen + BuildManager.WebAssemblyNamePrefix + baseName + ".dll")) { continue; } } } else { // Additional logic for VSWhidbey 564168 / Visual Studio QFE 4710. // Delete both original .dll and .delete if possible DiskBuildResultCache.CheckAndRemoveDotDeleteFile(new FileInfo(fileData.FullName)); continue; } Debug.Trace("BuildResultCache", "Deleting old temporary files: " + fileData.FullName); try { File.Delete(fileData.FullName); } catch { } } }
/* * Delete an assembly and all its related files. The assembly is typically named * something like ASPNET.jnw_y10n.dll, while related files are simply jnw_y10n.*. */ internal virtual void RemoveAssemblyAndRelatedFiles(string assemblyName) { Debug.Trace("DiskBuildResultCache", "RemoveAssemblyAndRelatedFiles(" + assemblyName + ")"); // If the name doesn't start with the prefix, the cleanup code doesn't apply if (!assemblyName.StartsWith(BuildManager.WebAssemblyNamePrefix, StringComparison.Ordinal)) { return; } // Get rid of the prefix, since related files don't have it string baseName = assemblyName.Substring(BuildManager.WebAssemblyNamePrefix.Length); bool gotLock = false; try { // Grab the compilation mutex, since we will remove generated assembly CompilationLock.GetLock(ref gotLock); DirectoryInfo directory = new DirectoryInfo(_cacheDir); // Find all the files that contain the base name FileInfo[] files = directory.GetFiles("*" + baseName + ".*"); foreach (FileInfo f in files) { if (f.Extension == ".dll") { // Notify existing buildresults that result assembly will be removed. // This is required otherwise new components can be compiled // with obsolete build results whose assembly has been removed. string assemblyKey = GetAssemblyCacheKey(f.FullName); HttpRuntime.CacheInternal.Remove(assemblyKey); // Remove the assembly RemoveAssembly(f); // Also, remove satellite assemblies that may be associated with it StandardDiskBuildResultCache.RemoveSatelliteAssemblies(assemblyName); } else if (f.Extension == dotDelete) { CheckAndRemoveDotDeleteFile(f); } else { // Remove the file, or if not possible, rename it, so it'll get // cleaned up next time by RemoveOldTempFiles() TryDeleteFile(f); } } } finally { // Always release the mutex if we had taken it if (gotLock) { CompilationLock.ReleaseLock(); } DiskBuildResultCache.ShutDownAppDomainIfRequired(); } }
internal PreservationFileReader(DiskBuildResultCache diskCache, bool precompilationMode) { this._diskCache = diskCache; this._precompilationMode = precompilationMode; }
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*/); } } }