/// <summary> /// Cached implementation of GetAssemblyName. /// </summary> /// <param name="path">The path to the file</param> /// <returns>The assembly name.</returns> private AssemblyNameExtension GetAssemblyName(string path) { // If the assembly is in an FX folder and its a well-known assembly // then we can short-circuit the File IO involved with GetAssemblyName() if (redistList != null) { string extension = Path.GetExtension(path); if (string.Equals(extension, ".dll", StringComparison.OrdinalIgnoreCase)) { IEnumerable <AssemblyEntry> assemblyNames = redistList.FindAssemblyNameFromSimpleName ( Path.GetFileNameWithoutExtension(path) ); string filename = Path.GetFileName(path); foreach (AssemblyEntry a in assemblyNames) { string pathFromRedistList = Path.Combine(a.FrameworkDirectory, filename); if (String.Equals(path, pathFromRedistList, StringComparison.OrdinalIgnoreCase)) { return(new AssemblyNameExtension(a.FullName)); } } } } // Not a well-known FX assembly so now check the cache. FileState fileState = GetFileState(path); if (fileState.Assembly == null) { fileState.Assembly = getAssemblyName(path); // Certain assemblies, like mscorlib may not have metadata. // Avoid continuously calling getAssemblyName on these files by // recording these as having an empty name. if (fileState.Assembly == null) { fileState.Assembly = AssemblyNameExtension.UnnamedAssembly; } isDirty = true; } if (fileState.Assembly.IsUnnamedAssembly) { return(null); } return(fileState.Assembly); }
/// <summary> /// Copy source to destination, unless SkipUnchangedFiles is true and they are equivalent. /// </summary> /// <returns>True if the file was copied or, on SkipUnchangedFiles, the file was equivalent.</returns> private bool DoCopyIfNecessary(FileState sourceFileState, FileState destinationFileState, CopyFileWithState copyFile) { bool success = true; try { if (SkipUnchangedFiles && IsMatchingSizeAndTimeStamp(sourceFileState, destinationFileState)) { // If we got here, then the file's time and size match AND // the user set the SkipUnchangedFiles flag which means we // should skip matching files. Log.LogMessageFromResources( MessageImportance.Low, "Copy.DidNotCopyBecauseOfFileMatch", sourceFileState.Name, destinationFileState.Name, "SkipUnchangedFiles", "true" ); } // We only do the cheap check for identicalness here, we try the more expensive check // of comparing the fullpaths of source and destination to see if they are identical, // in the exception handler lower down. else if (0 != String.Compare( sourceFileState.Name, destinationFileState.Name, StringComparison.OrdinalIgnoreCase)) { success = DoCopyWithRetries(sourceFileState, destinationFileState, copyFile); } } catch (OperationCanceledException) { success = false; } catch (PathTooLongException e) { Log.LogErrorWithCodeFromResources("Copy.Error", sourceFileState.Name, destinationFileState.Name, e.Message); success = false; } catch (Exception e) when(ExceptionHandling.IsIoRelatedException(e)) { Log.LogErrorWithCodeFromResources("Copy.Error", sourceFileState.Name, destinationFileState.Name, e.Message); success = false; } return(success); }
/// <summary> /// Ensure the read-only attribute on the specified file is off, so /// the file is writeable. /// </summary> private void MakeFileWriteable(FileState file, bool logActivity) { if (file.FileExists) { if (file.IsReadOnly) { if (logActivity) { Log.LogMessageFromResources(MessageImportance.Low, "Copy.RemovingReadOnlyAttribute", file.Name); } File.SetAttributes(file.Name, FileAttributes.Normal); file.Reset(); } } }
/// <summary> /// Method compares two files and returns true if their size and timestamp are identical. /// </summary> /// <param name="sourceFile">The source file</param> /// <param name="destinationFile">The destination file</param> private static bool IsMatchingSizeAndTimeStamp ( FileState sourceFile, FileState destinationFile ) { // If the destination doesn't exist, then it is not a matching file. if (!destinationFile.FileExists) { return(false); } if (sourceFile.LastWriteTimeUtcFast != destinationFile.LastWriteTimeUtcFast) { return(false); } if (sourceFile.Length != destinationFile.Length) { return(false); } return(true); }
/// <summary> /// Copy one file with the appropriate number of retries if it fails. /// </summary> private bool DoCopyWithRetries(FileState sourceFileState, FileState destinationFileState, CopyFileWithState copyFile) { int retries = 0; while (!_cancellationTokenSource.IsCancellationRequested) { try { bool?result = copyFile(sourceFileState, destinationFileState); if (result.HasValue) { return(result.Value); } } catch (OperationCanceledException) { break; } catch (Exception e) when(ExceptionHandling.IsIoRelatedException(e)) { if (e is ArgumentException || // Invalid chars e is NotSupportedException || // Colon in the middle of the path e is PathTooLongException) { // No use retrying these cases throw; } if (e is UnauthorizedAccessException || e is IOException) // Not clear why we can get one and not the other { int code = Marshal.GetHRForException(e); LogDiagnostic("Got {0} copying {1} to {2} and HR is {3}", e.ToString(), sourceFileState.Name, destinationFileState.Name, code); if (code == NativeMethods.ERROR_ACCESS_DENIED) { // ERROR_ACCESS_DENIED can either mean there's an ACL preventing us, or the file has the readonly bit set. // In either case, that's likely not a race, and retrying won't help. // Retrying is mainly for ERROR_SHARING_VIOLATION, where someone else is using the file right now. // However, there is a limited set of circumstances where a copy failure will show up as access denied due // to a failure to reset the readonly bit properly, in which case retrying will succeed. This seems to be // a pretty edge scenario, but since some of our internal builds appear to be hitting it, provide a secret // environment variable to allow overriding the default behavior and forcing retries in this circumstance as well. if (!s_alwaysRetryCopy) { throw; } else { LogDiagnostic("Retrying on ERROR_ACCESS_DENIED because MSBUILDALWAYSRETRY = 1"); } } } if (e is IOException && DestinationFolder != null && FileSystems.Default.FileExists(DestinationFolder.ItemSpec)) { // We failed to create the DestinationFolder because it's an existing file. No sense retrying. // We don't check for this case upstream because it'd be another hit to the filesystem. throw; } if (e is IOException) { // if this was just because the source and destination files are the // same file, that's not a failure. // Note -- we check this exceptional case here, not before the copy, for perf. if (PathsAreIdentical(sourceFileState.Name, destinationFileState.Name)) { return(true); } } if (retries < Retries) { retries++; Log.LogWarningWithCodeFromResources("Copy.Retrying", sourceFileState.Name, destinationFileState.Name, retries, RetryDelayMilliseconds, e.Message, GetLockedFileMessage(destinationFileState.Name)); // if we have to retry for some reason, wipe the state -- it may not be correct anymore. destinationFileState.Reset(); Thread.Sleep(RetryDelayMilliseconds); continue; } else if (Retries > 0) { // Exception message is logged in caller Log.LogErrorWithCodeFromResources("Copy.ExceededRetries", sourceFileState.Name, destinationFileState.Name, Retries, GetLockedFileMessage(destinationFileState.Name)); throw; } else { throw; } } if (retries < Retries) { retries++; Log.LogWarningWithCodeFromResources("Copy.Retrying", sourceFileState.Name, destinationFileState.Name, retries, RetryDelayMilliseconds, String.Empty /* no details */, GetLockedFileMessage(destinationFileState.Name)); // if we have to retry for some reason, wipe the state -- it may not be correct anymore. destinationFileState.Reset(); Thread.Sleep(RetryDelayMilliseconds); } else if (Retries > 0) { Log.LogErrorWithCodeFromResources("Copy.ExceededRetries", sourceFileState.Name, destinationFileState.Name, Retries, GetLockedFileMessage(destinationFileState.Name)); return(false); } else { return(false); } } // Canceling return(false); }
private void TryCopyViaLink(string linkComment, MessageImportance messageImportance, FileState sourceFileState, FileState destinationFileState, ref bool destinationFileExists, out bool linkCreated, ref string errorMessage, Func <string, string, string, bool> createLink) { // Do not log a fake command line as well, as it's superfluous, and also potentially expensive Log.LogMessageFromResources(MessageImportance.Normal, linkComment, sourceFileState.Name, destinationFileState.Name); if (!OverwriteReadOnlyFiles) { destinationFileExists = destinationFileState.FileExists; } // CreateHardLink and CreateSymbolicLink cannot overwrite an existing file or link // so we need to delete the existing entry before we create the hard or symbolic link. if (destinationFileExists) { FileUtilities.DeleteNoThrow(destinationFileState.Name); } linkCreated = createLink(sourceFileState.Name, destinationFileState.Name, errorMessage); if (!linkCreated) { // This is only a message since we don't want warnings when copying to network shares etc. Log.LogMessageFromResources(messageImportance, "Copy.RetryingAsFileCopy", sourceFileState.Name, destinationFileState.Name, errorMessage); } }
/// <summary> /// Copy one file from source to destination. Create the target directory if necessary and /// leave the file read-write. /// </summary> /// <returns>Return true to indicate success, return false to indicate failure and NO retry, return NULL to indicate retry.</returns> private bool?CopyFileWithLogging ( FileState sourceFileState, // The source file FileState destinationFileState // The destination file ) { bool destinationFileExists = false; if (destinationFileState.DirectoryExists) { Log.LogErrorWithCodeFromResources("Copy.DestinationIsDirectory", sourceFileState.Name, destinationFileState.Name); return(false); } if (sourceFileState.DirectoryExists) { // If the source file passed in is actually a directory instead of a file, log a nice // error telling the user so. Otherwise, .NET Framework's File.Copy method will throw // an UnauthorizedAccessException saying "access is denied", which is not very useful // to the user. Log.LogErrorWithCodeFromResources("Copy.SourceIsDirectory", sourceFileState.Name); return(false); } if (!sourceFileState.FileExists) { Log.LogErrorWithCodeFromResources("Copy.SourceFileNotFound", sourceFileState.Name); return(false); } string destinationFolder = Path.GetDirectoryName(destinationFileState.Name); if (!string.IsNullOrEmpty(destinationFolder) && !_directoriesKnownToExist.ContainsKey(destinationFolder)) { if (!FileSystems.Default.DirectoryExists(destinationFolder)) { Log.LogMessageFromResources(MessageImportance.Normal, "Copy.CreatesDirectory", destinationFolder); Directory.CreateDirectory(destinationFolder); } // It's very common for a lot of files to be copied to the same folder. // Eg., "c:\foo\a"->"c:\bar\a", "c:\foo\b"->"c:\bar\b" and so forth. // We don't want to check whether this folder exists for every single file we copy. So store which we've checked. _directoriesKnownToExist.TryAdd(destinationFolder, true); } if (OverwriteReadOnlyFiles) { MakeFileWriteable(destinationFileState, true); destinationFileExists = destinationFileState.FileExists; } bool linkCreated = false; string errorMessage = string.Empty; // If we want to create hard or symbolic links, then try that first if (UseHardlinksIfPossible) { TryCopyViaLink("Copy.HardLinkComment", MessageImportance.Normal, sourceFileState, destinationFileState, ref destinationFileExists, out linkCreated, ref errorMessage, (source, destination, errMessage) => NativeMethods.MakeHardLink(destination, source, ref errorMessage)); } else if (UseSymboliclinksIfPossible) { TryCopyViaLink("Copy.SymbolicLinkComment", MessageImportance.Normal, sourceFileState, destinationFileState, ref destinationFileExists, out linkCreated, ref errorMessage, (source, destination, errMessage) => NativeMethods.MakeSymbolicLink(destination, source, ref errorMessage)); } if (ErrorIfLinkFails && !linkCreated) { Log.LogErrorWithCodeFromResources("Copy.LinkFailed", sourceFileState.Name, destinationFileState.Name); return(false); } // If the link was not created (either because the user didn't want one, or because it couldn't be created) // then let's copy the file if (!linkCreated) { // Do not log a fake command line as well, as it's superfluous, and also potentially expensive string sourceFilePath = FileUtilities.GetFullPathNoThrow(sourceFileState.Name); string destinationFilePath = FileUtilities.GetFullPathNoThrow(destinationFileState.Name); Log.LogMessageFromResources(MessageImportance.Normal, "Copy.FileComment", sourceFilePath, destinationFilePath); File.Copy(sourceFileState.Name, destinationFileState.Name, true); } destinationFileState.Reset(); // If the destinationFile file exists, then make sure it's read-write. // The File.Copy command copies attributes, but our copy needs to // leave the file writeable. if (sourceFileState.IsReadOnly) { MakeFileWriteable(destinationFileState, false); } return(true); }