/// <summary> /// append a new symbol path element to the begining of the symbol path represented by 'this'. /// </summary> public void Add(SymPathElement elem) { if (elem != null && !_elements.Contains(elem)) { _elements.Add(elem); } }
/// <summary> /// insert a new symbol path element to the begining of the symbol path represented by 'this'. /// </summary> public void Insert(SymPathElement elem) { if (elem != null) { var existing = _elements.IndexOf(elem); if (existing >= 0) { _elements.RemoveAt(existing); } _elements.Insert(0, elem); } }
/// <summary> /// Implements object interface /// </summary> public override bool Equals(object obj) { SymPathElement asSymPathElem = obj as SymPathElement; if (asSymPathElem == null) { return(false); } return (Target == asSymPathElem.Target && Cache == asSymPathElem.Cache && IsSymServer == asSymPathElem.IsSymServer); }
private async Task <string> SearchSymbolServerForFile(string fileSimpleName, string fileIndexPath, Func <string, bool> match) { var tasks = new List <Task <string> >(); foreach (var element in SymPathElement.GetElements(SymbolPath)) { if (element.IsSymServer) { tasks.Add(TryGetFileFromServerAsync(element.Target, fileIndexPath, element.Cache ?? SymbolCache)); } else { string fullDestPath = Path.Combine(element.Cache ?? SymbolCache, fileIndexPath); string sourcePath = Path.Combine(element.Target, fileSimpleName); tasks.Add(CheckAndCopyRemoteFile(sourcePath, fullDestPath, match)); } } string result = await tasks.GetFirstNonNullResult(); return(result); }
/// <summary> /// Default implementation of finding a pdb. /// </summary> /// <param name="pdbName">The name the pdb is indexed under.</param> /// <param name="pdbIndexGuid">The guid the pdb is indexed under.</param> /// <param name="pdbIndexAge">The age of the pdb.</param> /// <returns>A full path on disk (local) of where the pdb was copied to.</returns> public override string FindPdb(string pdbName, Guid pdbIndexGuid, int pdbIndexAge) { if (string.IsNullOrEmpty(pdbName)) { return(null); } string pdbSimpleName = Path.GetFileName(pdbName); if (pdbName != pdbSimpleName) { if (ValidatePdb(pdbName, pdbIndexGuid, pdbIndexAge)) { return(pdbName); } } // Check to see if it's already cached. PdbEntry entry = new PdbEntry(pdbSimpleName, pdbIndexGuid, pdbIndexAge); string result = GetPdbEntry(entry); if (result != null) { return(result); } HashSet <PdbEntry> missingPdbs = _missingPdbs; if (IsMissing(missingPdbs, entry)) { return(null); } string pdbIndexPath = GetIndexPath(pdbSimpleName, pdbIndexGuid, pdbIndexAge); foreach (SymPathElement element in SymPathElement.GetElements(SymbolPath)) { if (element.IsSymServer) { string targetPath = TryGetFileFromServer(element.Target, pdbIndexPath, element.Cache ?? SymbolCache); if (targetPath != null) { Trace("Found pdb {0} from server '{1}' on path '{2}'. Copied to '{3}'.", pdbSimpleName, element.Target, pdbIndexPath, targetPath); SetPdbEntry(missingPdbs, entry, targetPath); return(targetPath); } Trace("No matching pdb found on server '{0}' on path '{1}'.", element.Target, pdbIndexPath); } else { string fullPath = Path.Combine(element.Target, pdbSimpleName); if (ValidatePdb(fullPath, pdbIndexGuid, pdbIndexAge)) { Trace($"Found pdb '{pdbSimpleName}' at '{fullPath}'."); SetPdbEntry(missingPdbs, entry, fullPath); return(fullPath); } Trace($"Mismatched pdb found at '{fullPath}'."); } } SetPdbEntry(missingPdbs, entry, null); return(null); }
/// <summary> /// Attempts to locate a binary via the symbol server. This function will then copy the file /// locally to the symbol cache and return the location of the local file on disk. /// </summary> /// <param name="fileName">The filename that the binary is indexed under.</param> /// <param name="buildTimeStamp">The build timestamp the binary is indexed under.</param> /// <param name="imageSize">The image size the binary is indexed under.</param> /// <param name="checkProperties">Whether or not to validate the properties of the binary after download.</param> /// <returns>A full path on disk (local) of where the binary was copied to, null if it was not found.</returns> public override string FindBinary(string fileName, int buildTimeStamp, int imageSize, bool checkProperties = true) { string fullPath = fileName; fileName = Path.GetFileName(fullPath).ToLower(); // First see if we already have the result cached. FileEntry entry = new FileEntry(fileName, buildTimeStamp, imageSize); string result = GetFileEntry(entry); if (result != null) { return(result); } HashSet <FileEntry> missingFiles = _missingFiles; if (IsMissing(missingFiles, entry)) { return(null); } // Test to see if the file is on disk. if (ValidateBinary(fullPath, buildTimeStamp, imageSize, checkProperties)) { SetFileEntry(missingFiles, entry, fullPath); return(fullPath); } // Finally, check the symbol paths. string exeIndexPath = null; foreach (SymPathElement element in SymPathElement.GetElements(SymbolPath)) { if (element.IsSymServer) { if (exeIndexPath == null) { exeIndexPath = GetIndexPath(fileName, buildTimeStamp, imageSize); } string target = TryGetFileFromServer(element.Target, exeIndexPath, element.Cache ?? SymbolCache); if (target == null) { Trace($"Server '{element.Target}' did not have file '{Path.GetFileName(fileName)}' with timestamp={buildTimeStamp:x} and filesize={imageSize:x}."); } else if (ValidateBinary(target, buildTimeStamp, imageSize, checkProperties)) { Trace($"Found '{fileName}' on server '{element.Target}'. Copied to '{target}'."); SetFileEntry(missingFiles, entry, target); return(target); } } else { string filePath = Path.Combine(element.Target, fileName); if (ValidateBinary(filePath, buildTimeStamp, imageSize, checkProperties)) { Trace($"Found '{fileName}' at '{filePath}'."); SetFileEntry(missingFiles, entry, filePath); return(filePath); } } } SetFileEntry(missingFiles, entry, null); return(null); }
/// <summary> /// insert a new symbol path element to the begining of the symbol path represented by 'this'. /// </summary> public void Insert(SymPathElement elem) { if (elem != null) { var existing = m_elements.IndexOf(elem); if (existing >= 0) m_elements.RemoveAt(existing); m_elements.Insert(0, elem); } }
/// <summary> /// append a new symbol path element to the begining of the symbol path represented by 'this'. /// </summary> public void Add(SymPathElement elem) { if (elem != null && !m_elements.Contains(elem)) m_elements.Add(elem); }