/// <summary> /// Resolves the source path of a file. /// </summary> /// <param name="source">Original source value.</param> /// <param name="type">Optional type of source file being resolved.</param> /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param> /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param> /// <returns>Should return a valid path for the stream to be imported.</returns> public virtual string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage) { if (String.IsNullOrEmpty(source)) { throw new ArgumentNullException("source"); } if (BinderFileManager.CheckFileExists(source)) // if the file exists, we're good to go. { return(source); } else if (Path.IsPathRooted(source)) // path is rooted so bindpaths won't help, bail since the file apparently doesn't exist. { return(null); } else // not a rooted path so let's try applying all the different source resolution options. { const string bindPathOpenString = "!(bindpath."; string bindName = String.Empty; string path = source; string pathWithoutSourceDir = null; if (source.StartsWith(bindPathOpenString, StringComparison.Ordinal)) { int closeParen = source.IndexOf(')', bindPathOpenString.Length); if (-1 != closeParen) { bindName = source.Substring(bindPathOpenString.Length, closeParen - bindPathOpenString.Length); path = source.Substring(bindPathOpenString.Length + bindName.Length + 1); // +1 for the closing brace. path = path.TrimStart('\\'); // remove starting '\\' char so the path doesn't look rooted. } } else if (source.StartsWith("SourceDir\\", StringComparison.Ordinal) || source.StartsWith("SourceDir/", StringComparison.Ordinal)) { pathWithoutSourceDir = path.Substring(10); } var bindPaths = this.Core.GetBindPaths(bindStage, bindName); foreach (string bindPath in bindPaths) { string filePath; if (!String.IsNullOrEmpty(pathWithoutSourceDir)) { filePath = Path.Combine(bindPath, pathWithoutSourceDir); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } filePath = Path.Combine(bindPath, path); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } } // Didn't find the file. return(null); }
public virtual CabinetBuildOption ResolveCabinet(FileRowCollection fileRows, ref string cabinetPath) { if (fileRows == null) { throw new ArgumentNullException("fileRows"); } // no special behavior specified, use the default if (null == this.cabCachePath && !this.reuseCabinets) { return(CabinetBuildOption.BuildAndMove); } // if a cabinet cache path was provided, change the location for the cabinet // to be built to if (null != this.cabCachePath) { string cabinetName = Path.GetFileName(cabinetPath); cabinetPath = Path.Combine(this.cabCachePath, cabinetName); } // if we still think we're going to reuse the cabinet check to see if the cabinet exists first if (this.reuseCabinets) { bool cabinetValid = false; if (BinderFileManager.CheckFileExists(cabinetPath)) { // check to see if // 1. any files are added or removed // 2. order of files changed or names changed // 3. modified time changed cabinetValid = true; // Need to force garbage collection of WixEnumerateCab to ensure the handle // associated with it is closed before it is reused. using (Cab.WixEnumerateCab wixEnumerateCab = new Cab.WixEnumerateCab()) { ArrayList fileList = wixEnumerateCab.Enumerate(cabinetPath); if (fileRows.Count != fileList.Count) { cabinetValid = false; } else { int i = 0; foreach (FileRow fileRow in fileRows) { // First check that the file identifiers match because that is quick and easy. CabinetFileInfo cabFileInfo = fileList[i] as CabinetFileInfo; cabinetValid = (cabFileInfo.FileId == fileRow.File); if (cabinetValid) { // Still valid so ensure the source time stamp hasn't changed. Thus we need // to convert the source file time stamp into a cabinet compatible data/time. DateTime sourceFileTime = File.GetLastWriteTime(fileRow.Source); ushort sourceCabDate; ushort sourceCabTime; Cab.Interop.CabInterop.DateTimeToCabDateAndTime(sourceFileTime, out sourceCabDate, out sourceCabTime); cabinetValid = (cabFileInfo.Date == sourceCabDate && cabFileInfo.Time == sourceCabTime); } if (!cabinetValid) { break; } i++; } } } } return(cabinetValid ? CabinetBuildOption.Copy : CabinetBuildOption.BuildAndCopy); } else // by default move the built cabinet { return(CabinetBuildOption.BuildAndMove); } }
public virtual ResolvedCabinet ResolveCabinet(string cabinetPath, IEnumerable <BindFileWithPath> filesWithPath) { if (null == filesWithPath) { throw new ArgumentNullException("fileRows"); } // By default cabinet should be built and moved to the suggested location. ResolvedCabinet resolved = new ResolvedCabinet() { BuildOption = CabinetBuildOption.BuildAndMove, Path = cabinetPath }; // If a cabinet cache path was provided, change the location for the cabinet // to be built to and check if there is a cabinet that can be reused. if (!String.IsNullOrEmpty(this.Core.CabCachePath)) { string cabinetName = Path.GetFileName(cabinetPath); resolved.Path = Path.Combine(this.Core.CabCachePath, cabinetName); if (BinderFileManager.CheckFileExists(resolved.Path)) { // Assume that none of the following are true: // 1. any files are added or removed // 2. order of files changed or names changed // 3. modified time changed bool cabinetValid = true; // Need to force garbage collection of WixEnumerateCab to ensure the handle // associated with it is closed before it is reused. using (Cab.WixEnumerateCab wixEnumerateCab = new Cab.WixEnumerateCab()) { List <CabinetFileInfo> fileList = wixEnumerateCab.Enumerate(resolved.Path); if (filesWithPath.Count() != fileList.Count) { cabinetValid = false; } else { int i = 0; foreach (BindFileWithPath file in filesWithPath) { // First check that the file identifiers match because that is quick and easy. CabinetFileInfo cabFileInfo = fileList[i]; cabinetValid = (cabFileInfo.FileId == file.Id); if (cabinetValid) { // Still valid so ensure the file sizes are the same. FileInfo fileInfo = new FileInfo(file.Path); cabinetValid = (cabFileInfo.Size == fileInfo.Length); if (cabinetValid) { // Still valid so ensure the source time stamp hasn't changed. Thus we need // to convert the source file time stamp into a cabinet compatible data/time. ushort sourceCabDate; ushort sourceCabTime; WixToolset.Core.Native.CabInterop.DateTimeToCabDateAndTime(fileInfo.LastWriteTime, out sourceCabDate, out sourceCabTime); cabinetValid = (cabFileInfo.Date == sourceCabDate && cabFileInfo.Time == sourceCabTime); } } if (!cabinetValid) { break; } i++; } } } resolved.BuildOption = cabinetValid ? CabinetBuildOption.Copy : CabinetBuildOption.BuildAndCopy; } } return(resolved); }
/// <summary> /// Resolves the source path of a file. /// </summary> /// <param name="source">Original source value.</param> /// <param name="type">Optional type of source file being resolved.</param> /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param> /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param> /// <returns>Should return a valid path for the stream to be imported.</returns> public virtual string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage) { // the following new local variables are used for bind path and protect the changes to object field. StringCollection currentBindPaths = null; NameValueCollection currentNamedBindPaths = null; StringCollection currentSourcePaths = null; if (String.IsNullOrEmpty(source)) { throw new ArgumentNullException("source"); } // Call the original override function first. If it returns an answer then return that, // otherwise using the default resolving logic string filePath = this.ResolveFile(source, type, sourceLineNumbers); if (!String.IsNullOrEmpty(filePath)) { return(filePath); } // Assign the correct bind path to file manager currentSourcePaths = this.sourcePaths[bindStage]; currentNamedBindPaths = this.namedBindPaths[bindStage]; if (BindStage.Target != bindStage && BindStage.Updated != bindStage) { currentBindPaths = this.bindPaths[bindStage]; } else { currentBindPaths = this.sourcePaths[bindStage]; } // If the path is rooted, it better exist or we're not going to find it. if (Path.IsPathRooted(source)) { if (BinderFileManager.CheckFileExists(source)) { return(source); } } else // not a rooted path so let's try applying all the different source resolution options. { const string bindPathOpenString = "!(bindpath."; if (source.StartsWith(bindPathOpenString, StringComparison.Ordinal) && source.IndexOf(')') != -1) { int bindpathSignatureLength = bindPathOpenString.Length; string name = source.Substring(bindpathSignatureLength, source.IndexOf(')') - bindpathSignatureLength); string[] values = currentNamedBindPaths.GetValues(name); if (null != values) { foreach (string bindPath in values) { // Parse out '\\' chars that separate the "bindpath" variable and the next part of the path, // because Path.Combine() thinks that rooted second paths don't need the first path. string nameSection = string.Empty; int nameStart = bindpathSignatureLength + 1 + name.Length; // +1 for the closing bracket. nameSection = source.Substring(nameStart).TrimStart('\\'); filePath = Path.Combine(bindPath, nameSection); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } } } else if (source.StartsWith("SourceDir\\", StringComparison.Ordinal) || source.StartsWith("SourceDir/", StringComparison.Ordinal)) { foreach (string bindPath in currentBindPaths) { filePath = Path.Combine(bindPath, source.Substring(10)); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } } else if (BinderFileManager.CheckFileExists(source)) { return(source); } foreach (string path in currentSourcePaths) { filePath = Path.Combine(path, source); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } if (source.StartsWith("SourceDir\\", StringComparison.Ordinal) || source.StartsWith("SourceDir/", StringComparison.Ordinal)) { filePath = Path.Combine(path, source.Substring(10)); if (BinderFileManager.CheckFileExists(filePath)) { return(filePath); } } } } // Didn't find the file. throw new WixFileNotFoundException(sourceLineNumbers, source, type); }