예제 #1
0
 public void SaveTlog(DependencyFilter includeInTLog)
 {
     if ((this.tlogFiles != null) && (this.tlogFiles.Length > 0))
     {
         string key = DependencyTableCache.FormatNormalizedTlogRootingMarker(this.tlogFiles);
         lock (DependencyTableCache.DependencyTable)
         {
             if (DependencyTableCache.DependencyTable.ContainsKey(key))
             {
                 DependencyTableCache.DependencyTable.Remove(key);
             }
         }
         string itemSpec = this.tlogFiles[0].ItemSpec;
         foreach (ITaskItem item in this.tlogFiles)
         {
             File.WriteAllText(item.ItemSpec, "", Encoding.Unicode);
         }
         using (StreamWriter writer = new StreamWriter(itemSpec, false, Encoding.Unicode))
         {
             foreach (string str3 in this.dependencyTable.Keys)
             {
                 Dictionary <string, DateTime> dictionary = this.dependencyTable[str3];
                 writer.WriteLine("^" + str3);
                 foreach (string str4 in dictionary.Keys)
                 {
                     if ((includeInTLog == null) || includeInTLog(str4))
                     {
                         writer.WriteLine(str4);
                     }
                 }
             }
         }
     }
 }
예제 #2
0
        public void SaveTlog(DependencyFilter includeInTLog)
        {
            if (_tlogFiles != null && (_tlogFiles.Length > 0))
            {
                string tLogRootingMarker = DependencyTableCache.FormatNormalizedTlogRootingMarker(_tlogFiles);

                lock (DependencyTableCache.DependencyTable)
                {
                    // The tracking logs in the cache will be invalidated by this write
                    // remove the cached entries to be sure
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                }

                string firstTlog = _tlogFiles[0].ItemSpec;

                // empty all tlogs
                foreach (ITaskItem tlogFile in _tlogFiles)
                {
                    File.WriteAllText(tlogFile.ItemSpec, "", Encoding.Unicode);
                }

                // Write out the dependency information as a new tlog
                using (StreamWriter newTlog = new StreamWriter(firstTlog, false, Encoding.Unicode))
                {
                    foreach (string fileEntry in _dependencyTable.Keys)
                    {
                        // Give the task a chance to filter dependencies out of the written TLog
                        if (includeInTLog == null || includeInTLog(fileEntry))
                        {
                            // Write out the entry
                            newTlog.WriteLine(fileEntry);
                        }
                    }
                }
            }
            else if (_tlogMarker != String.Empty)
            {
                string markerDirectory = Path.GetDirectoryName(_tlogMarker);
                if (!Directory.Exists(markerDirectory))
                {
                    Directory.CreateDirectory(markerDirectory);
                }

                // There were no TLogs to save, so use the TLog marker
                // to create a marker file that can be used for up-to-date check.
                File.WriteAllText(_tlogMarker, "");
            }
        }
        public void SaveTlog(DependencyFilter includeInTLog)
        {
            if (_tlogFiles != null && (_tlogFiles.Length > 0))
            {
                string tLogRootingMarker = DependencyTableCache.FormatNormalizedTlogRootingMarker(_tlogFiles);

                lock (DependencyTableCache.DependencyTable)
                {
                    // The tracking logs in the cache will be invalidated by this compaction
                    // remove the cached entries to be sure
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                }

                string firstTlog = _tlogFiles[0].ItemSpec;

                // empty all tlogs
                foreach (ITaskItem tlogFile in _tlogFiles)
                {
                    File.WriteAllText(tlogFile.ItemSpec, "", System.Text.Encoding.Unicode);
                }

                // Write out the dependency information as a new tlog
                using (StreamWriter outputs = new StreamWriter(firstTlog, false, System.Text.Encoding.Unicode))
                {
                    foreach (string rootingMarker in _dependencyTable.Keys)
                    {
                        Dictionary <string, DateTime> dependencies = _dependencyTable[rootingMarker];
                        outputs.WriteLine("^" + rootingMarker);
                        foreach (string file in dependencies.Keys)
                        {
                            // Give the task a chance to filter dependencies out of the written TLog
                            if (includeInTLog == null || includeInTLog(file))
                            {
                                // Write out the entry
                                outputs.WriteLine(file);
                            }
                        }
                    }
                }
            }
        }
 public void SaveTlog(DependencyFilter includeInTLog)
 {
     if ((this.tlogFiles != null) && (this.tlogFiles.Length > 0))
     {
         string key = DependencyTableCache.FormatNormalizedTlogRootingMarker(this.tlogFiles);
         lock (DependencyTableCache.DependencyTable)
         {
             if (DependencyTableCache.DependencyTable.ContainsKey(key))
             {
                 DependencyTableCache.DependencyTable.Remove(key);
             }
         }
         string itemSpec = this.tlogFiles[0].ItemSpec;
         foreach (ITaskItem item in this.tlogFiles)
         {
             File.WriteAllText(item.ItemSpec, "", Encoding.Unicode);
         }
         using (StreamWriter writer = new StreamWriter(itemSpec, false, Encoding.Unicode))
         {
             foreach (string str3 in this.dependencyTable.Keys)
             {
                 if ((includeInTLog == null) || includeInTLog(str3))
                 {
                     writer.WriteLine(str3);
                 }
             }
             return;
         }
     }
     if (this.tlogMarker != string.Empty)
     {
         string directoryName = Path.GetDirectoryName(this.tlogMarker);
         if (!Directory.Exists(directoryName))
         {
             Directory.CreateDirectory(directoryName);
         }
         File.WriteAllText(this.tlogMarker, "");
     }
 }
        private void ConstructFileTable()
        {
            string tLogRootingMarker = null;
            bool   flag2;
            bool   flag3;

            try
            {
                tLogRootingMarker = DependencyTableCache.FormatNormalizedTlogRootingMarker(this.tlogFiles);
            }
            catch (ArgumentException exception)
            {
                FileTracker.LogWarningWithCodeFromResources(this.Log, "Tracking_RebuildingDueToInvalidTLog", new object[] { exception.Message });
                return;
            }
            if (this.tlogsAvailable)
            {
                DependencyTableCacheEntry cachedEntry = null;
                lock (DependencyTableCache.DependencyTable)
                {
                    cachedEntry = DependencyTableCache.GetCachedEntry(tLogRootingMarker);
                }
                if (cachedEntry != null)
                {
                    this.dependencyTable = (IDictionary <string, DateTime>)cachedEntry.DependencyTable;
                    this.UpdateFileEntryDetails();
                    FileTracker.LogMessageFromResources(this.Log, MessageImportance.Low, "Tracking_TrackingCached", new object[0]);
                    foreach (ITaskItem item in cachedEntry.TlogFiles)
                    {
                        FileTracker.LogMessage(this.Log, MessageImportance.Low, "\t{0}", new object[] { item.ItemSpec });
                    }
                    return;
                }
                FileTracker.LogMessageFromResources(this.Log, MessageImportance.Low, "Tracking_TrackingLogs", new object[0]);
                flag2 = false;
                flag3 = false;
                string itemSpec = null;
                foreach (ITaskItem item2 in this.tlogFiles)
                {
                    try
                    {
                        FileTracker.LogMessage(this.Log, MessageImportance.Low, "\t{0}", new object[] { item2.ItemSpec });
                        DateTime lastWriteTimeUtc = NativeMethods.GetLastWriteTimeUtc(item2.ItemSpec);
                        if (lastWriteTimeUtc > this.newestTLogTimeUtc)
                        {
                            this.newestTLogTimeUtc  = lastWriteTimeUtc;
                            this.newestTLogFileName = item2.ItemSpec;
                        }
                        using (StreamReader reader = File.OpenText(item2.ItemSpec))
                        {
                            string key = reader.ReadLine();
                            while (key != null)
                            {
                                if (key.Length == 0)
                                {
                                    flag2    = true;
                                    itemSpec = item2.ItemSpec;
                                    goto Label_02B7;
                                }
                                if (key[0] == '#')
                                {
                                    key = reader.ReadLine();
                                    continue;
                                }
                                if ((key[0] == '^') && this.TreatRootMarkersAsEntries)
                                {
                                    key = key.Substring(1);
                                    if (key.Length != 0)
                                    {
                                        goto Label_0242;
                                    }
                                    flag2    = true;
                                    itemSpec = item2.ItemSpec;
                                    goto Label_02B7;
                                }
                                if (key[0] == '^')
                                {
                                    key = reader.ReadLine();
                                    continue;
                                }
Label_0242:
                                if (!this.dependencyTable.ContainsKey(key) && !FileTracker.FileIsExcludedFromDependencies(key))
                                {
                                    this.RecordEntryDetails(key, true);
                                }
                                key = reader.ReadLine();
                            }
                        }
                    }
                    catch (Exception exception2)
                    {
                        if (ExceptionHandling.NotExpectedException(exception2))
                        {
                            throw;
                        }
                        FileTracker.LogWarningWithCodeFromResources(this.Log, "Tracking_RebuildingDueToInvalidTLog", new object[] { exception2.Message });
                        break;
                    }
Label_02B7:
                    if (flag2)
                    {
                        FileTracker.LogWarningWithCodeFromResources(this.Log, "Tracking_RebuildingDueToInvalidTLogContents", new object[] { itemSpec });
                        break;
                    }
                }
            }
            else
            {
                lock (DependencyTableCache.DependencyTable)
                {
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                }
                return;
            }
            lock (DependencyTableCache.DependencyTable)
            {
                if (flag2 || flag3)
                {
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                    this.dependencyTable = new Dictionary <string, DateTime>(StringComparer.OrdinalIgnoreCase);
                }
                else
                {
                    DependencyTableCache.DependencyTable[tLogRootingMarker] = new DependencyTableCacheEntry(this.tlogFiles, (IDictionary)this.dependencyTable);
                }
            }
        }
        /// <summary>
        /// Construct our dependency table for our source files
        /// </summary>
        private void ConstructOutputTable()
        {
            string tLogRootingMarker = null;

            try
            {
                // construct a rooting marker from the tlog files
                tLogRootingMarker = DependencyTableCache.FormatNormalizedTlogRootingMarker(_tlogFiles);
            }
            catch (ArgumentException e)
            {
                FileTracker.LogWarningWithCodeFromResources(_log, "Tracking_RebuildingDueToInvalidTLog", e.Message);
                return;
            }

            // Record the current directory (which under normal circumstances will be the project directory)
            // so that we can compare tracked paths against it for inclusion in the dependency graph
            string currentProjectDirectory = FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory());

            if (!_tlogAvailable)
            {
                FileTracker.LogMessageFromResources(_log, MessageImportance.Low, "Tracking_TrackingLogNotAvailable");
                lock (DependencyTableCache.DependencyTable)
                {
                    // The tracking logs are not available, they may have been deleted at some point.
                    // Be safe and remove any references from the cache.
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                }
                return;
            }

            DependencyTableCacheEntry cachedEntry = null;

            lock (DependencyTableCache.DependencyTable)
            {
                // Look in the dependency table cache to see if its available and up to date
                cachedEntry = DependencyTableCache.GetCachedEntry(tLogRootingMarker);
            }

            // We have an up to date cached entry
            if (cachedEntry != null)
            {
                _dependencyTable = (Dictionary <string, System.Collections.Generic.Dictionary <string, System.DateTime> >)cachedEntry.DependencyTable;
                // Log information about what we're using
                FileTracker.LogMessageFromResources(_log, MessageImportance.Low, "Tracking_WriteTrackingCached");
                foreach (ITaskItem tlogItem in cachedEntry.TlogFiles)
                {
                    FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogItem.ItemSpec);
                }
                return;
            }

            FileTracker.LogMessageFromResources(_log, MessageImportance.Low, "Tracking_WriteTrackingLogs");

            // Now we need to construct the rest of the table from the TLOG files
            // If there are any errors in the tlogs, we want to warn, stop parsing tlogs, and empty
            // out the dependency table, essentially forcing a rebuild.
            bool   encounteredInvalidTLogContents = false;
            bool   exceptionCaught = false;
            string invalidTLogName = null;

            foreach (ITaskItem tlogFileName in _tlogFiles)
            {
                FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogFileName.ItemSpec);

                try
                {
                    using (StreamReader tlog = File.OpenText(tlogFileName.ItemSpec))
                    {
                        string tlogEntry = tlog.ReadLine();

                        while (tlogEntry != null)
                        {
                            if (tlogEntry.Length == 0)
                            {
                                encounteredInvalidTLogContents = true;
                                invalidTLogName = tlogFileName.ItemSpec;
                                break;
                            }

                            if (tlogEntry[0] == '^') // This is a rooting record, follow the outputs for it
                            {
                                Dictionary <string, DateTime> dependencies;

                                tlogEntry = tlogEntry.Substring(1);

                                if (tlogEntry.Length == 0)
                                {
                                    encounteredInvalidTLogContents = true;
                                    invalidTLogName = tlogFileName.ItemSpec;
                                    break;
                                }

                                if (!_dependencyTable.TryGetValue(tlogEntry, out dependencies))
                                {
                                    dependencies = new Dictionary <string, DateTime>(StringComparer.OrdinalIgnoreCase);
                                    _dependencyTable.Add(tlogEntry, dependencies);
                                }

                                // Process each file encountered until we hit a rooting marker
                                do
                                {
                                    tlogEntry = tlog.ReadLine();

                                    if (tlogEntry != null)
                                    {
                                        if (tlogEntry.Length == 0)
                                        {
                                            encounteredInvalidTLogContents = true;
                                            invalidTLogName = tlogFileName.ItemSpec;
                                            break;
                                        }
                                        else if ((tlogEntry[0] != '^') && (tlogEntry[0] != '#') && (!dependencies.ContainsKey(tlogEntry)))
                                        {
                                            // Allows incremental build of projects existing under temp, only for those reads / writes that
                                            // either are not under temp, or are recursively beneath the current project directory.
                                            if (FileTracker.FileIsUnderPath(tlogEntry, currentProjectDirectory) || !FileTracker.FileIsExcludedFromDependencies(tlogEntry))
                                            {
                                                DateTime fileModifiedTime = NativeMethods.GetLastWriteTimeUtc(tlogEntry);

                                                dependencies.Add(tlogEntry, fileModifiedTime);
                                            }
                                        }
                                    }
                                } while ((tlogEntry != null) && (tlogEntry[0] != '^'));

                                if (encounteredInvalidTLogContents)
                                {
                                    break;
                                }
                            }
                            else // don't know what this entry is, so skip it
                            {
                                tlogEntry = tlog.ReadLine();
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    if (ExceptionHandling.NotExpectedException(e))
                    {
                        throw;
                    }

                    FileTracker.LogWarningWithCodeFromResources(_log, "Tracking_RebuildingDueToInvalidTLog", e.Message);
                    break;
                }

                if (encounteredInvalidTLogContents)
                {
                    FileTracker.LogWarningWithCodeFromResources(_log, "Tracking_RebuildingDueToInvalidTLogContents", invalidTLogName);
                    break;
                }
            }

            lock (DependencyTableCache.DependencyTable)
            {
                // There were problems with the tracking logs -- we've already warned or errored; now we want to make
                // sure that we essentially force a rebuild of this particular root.
                if (encounteredInvalidTLogContents || exceptionCaught)
                {
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }

                    _dependencyTable = new Dictionary <string, Dictionary <string, DateTime> >(StringComparer.OrdinalIgnoreCase);
                }
                else
                {
                    // Record the newly built valid dependency table in the cache
                    DependencyTableCache.DependencyTable[tLogRootingMarker] = new DependencyTableCacheEntry(_tlogFiles, _dependencyTable);
                }
            }
        }
        private void ConstructDependencyTable()
        {
            string tLogRootingMarker = null;
            bool   flag2;
            bool   flag3;

            try
            {
                tLogRootingMarker = DependencyTableCache.FormatNormalizedTlogRootingMarker(this.tlogFiles);
            }
            catch (ArgumentException exception)
            {
                FileTracker.LogWarningWithCodeFromResources(this.Log, "Tracking_RebuildingDueToInvalidTLog", new object[] { exception.Message });
                return;
            }
            string path = FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory());

            if (this.tlogAvailable)
            {
                DependencyTableCacheEntry cachedEntry = null;
                lock (DependencyTableCache.DependencyTable)
                {
                    cachedEntry = DependencyTableCache.GetCachedEntry(tLogRootingMarker);
                }
                if (cachedEntry != null)
                {
                    this.dependencyTable = (Dictionary <string, Dictionary <string, string> >)cachedEntry.DependencyTable;
                    FileTracker.LogMessageFromResources(this.Log, MessageImportance.Low, "Tracking_ReadTrackingCached", new object[0]);
                    foreach (ITaskItem item2 in cachedEntry.TlogFiles)
                    {
                        FileTracker.LogMessage(this.Log, MessageImportance.Low, "\t{0}", new object[] { item2.ItemSpec });
                    }
                    return;
                }
                flag2 = false;
                flag3 = false;
                string itemSpec = null;
                FileTracker.LogMessageFromResources(this.Log, MessageImportance.Low, "Tracking_ReadTrackingLogs", new object[0]);
                foreach (ITaskItem item3 in this.tlogFiles)
                {
                    try
                    {
                        FileTracker.LogMessage(this.Log, MessageImportance.Low, "\t{0}", new object[] { item3.ItemSpec });
                        using (StreamReader reader = File.OpenText(item3.ItemSpec))
                        {
                            string key = reader.ReadLine();
                            while (key != null)
                            {
                                Dictionary <string, string> dictionary;
                                Dictionary <string, string> dictionary2;
                                if (key.Length == 0)
                                {
                                    flag2    = true;
                                    itemSpec = item3.ItemSpec;
                                    goto Label_04A1;
                                }
                                if (key[0] == '#')
                                {
                                    goto Label_044D;
                                }
                                bool flag4 = false;
                                if (key[0] == '^')
                                {
                                    key = key.Substring(1);
                                    if (key.Length == 0)
                                    {
                                        flag2    = true;
                                        itemSpec = item3.ItemSpec;
                                        goto Label_04A1;
                                    }
                                    flag4 = true;
                                }
                                if (!flag4)
                                {
                                    goto Label_0442;
                                }
                                if (!this.maintainCompositeRootingMarkers)
                                {
                                    dictionary2 = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
                                    if (key.Contains("|"))
                                    {
                                        foreach (ITaskItem item4 in this.sourceFiles)
                                        {
                                            dictionary2.Add(FileUtilities.NormalizePath(item4.ItemSpec), null);
                                        }
                                    }
                                    else
                                    {
                                        dictionary2.Add(key, null);
                                    }
                                }
                                else
                                {
                                    dictionary2 = null;
                                }
                                if (!this.dependencyTable.TryGetValue(key, out dictionary))
                                {
                                    dictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
                                    if (!this.maintainCompositeRootingMarkers)
                                    {
                                        dictionary.Add(key, null);
                                    }
                                    this.dependencyTable.Add(key, dictionary);
                                }
                                key = reader.ReadLine();
                                if (!this.maintainCompositeRootingMarkers)
                                {
                                    goto Label_0439;
                                }
                                while (key != null)
                                {
                                    if (key.Length == 0)
                                    {
                                        flag2    = true;
                                        itemSpec = item3.ItemSpec;
                                        break;
                                    }
                                    if ((key[0] == '#') || (key[0] == '^'))
                                    {
                                        break;
                                    }
                                    if (!dictionary.ContainsKey(key) && (FileTracker.FileIsUnderPath(key, path) || !FileTracker.FileIsExcludedFromDependencies(key)))
                                    {
                                        dictionary.Add(key, null);
                                    }
                                    key = reader.ReadLine();
                                }
                                continue;
Label_038D:
                                if (key.Length == 0)
                                {
                                    flag2    = true;
                                    itemSpec = item3.ItemSpec;
                                    continue;
                                }
                                if ((key[0] == '#') || (key[0] == '^'))
                                {
                                    continue;
                                }
                                if (dictionary2.ContainsKey(key))
                                {
                                    if (!this.dependencyTable.TryGetValue(key, out dictionary))
                                    {
                                        dictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
                                        dictionary.Add(key, null);
                                        this.dependencyTable.Add(key, dictionary);
                                    }
                                }
                                else if (!dictionary.ContainsKey(key) && (FileTracker.FileIsUnderPath(key, path) || !FileTracker.FileIsExcludedFromDependencies(key)))
                                {
                                    dictionary.Add(key, null);
                                }
                                key = reader.ReadLine();
Label_0439:
                                if (key != null)
                                {
                                    goto Label_038D;
                                }
                                continue;
Label_0442:
                                key = reader.ReadLine();
                                continue;
Label_044D:
                                key = reader.ReadLine();
                            }
                        }
                    }
                    catch (Exception exception2)
                    {
                        if (ExceptionHandling.NotExpectedException(exception2))
                        {
                            throw;
                        }
                        FileTracker.LogWarningWithCodeFromResources(this.Log, "Tracking_RebuildingDueToInvalidTLog", new object[] { exception2.Message });
                        break;
                    }
Label_04A1:
                    if (flag2)
                    {
                        FileTracker.LogWarningWithCodeFromResources(this.Log, "Tracking_RebuildingDueToInvalidTLogContents", new object[] { itemSpec });
                        break;
                    }
                }
            }
            else
            {
                foreach (ITaskItem item in this.tlogFiles)
                {
                    if (!FileUtilities.FileExistsNoThrow(item.ItemSpec))
                    {
                        FileTracker.LogMessageFromResources(this.Log, MessageImportance.Low, "Tracking_SingleLogFileNotAvailable", new object[] { item.ItemSpec });
                    }
                }
                lock (DependencyTableCache.DependencyTable)
                {
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                }
                return;
            }
            lock (DependencyTableCache.DependencyTable)
            {
                if (flag2 || flag3)
                {
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                    this.dependencyTable = new Dictionary <string, Dictionary <string, string> >(StringComparer.OrdinalIgnoreCase);
                }
                else
                {
                    DependencyTableCache.DependencyTable[tLogRootingMarker] = new DependencyTableCacheEntry(this.tlogFiles, this.dependencyTable);
                }
            }
        }
예제 #8
0
        private void ConstructOutputTable()
        {
            string tLogRootingMarker = null;
            bool   flag2;
            bool   flag3;

            try
            {
                tLogRootingMarker = DependencyTableCache.FormatNormalizedTlogRootingMarker(this.tlogFiles);
            }
            catch (ArgumentException exception)
            {
                FileTracker.LogWarningWithCodeFromResources(this.Log, "Tracking_RebuildingDueToInvalidTLog", new object[] { exception.Message });
                return;
            }
            string path = FileUtilities.EnsureTrailingSlash(Directory.GetCurrentDirectory());

            if (this.tlogAvailable)
            {
                DependencyTableCacheEntry cachedEntry = null;
                lock (DependencyTableCache.DependencyTable)
                {
                    cachedEntry = DependencyTableCache.GetCachedEntry(tLogRootingMarker);
                }
                if (cachedEntry != null)
                {
                    this.dependencyTable = (Dictionary <string, Dictionary <string, DateTime> >)cachedEntry.DependencyTable;
                    FileTracker.LogMessageFromResources(this.Log, MessageImportance.Low, "Tracking_WriteTrackingCached", new object[0]);
                    foreach (ITaskItem item in cachedEntry.TlogFiles)
                    {
                        FileTracker.LogMessage(this.Log, MessageImportance.Low, "\t{0}", new object[] { item.ItemSpec });
                    }
                    return;
                }
                FileTracker.LogMessageFromResources(this.Log, MessageImportance.Low, "Tracking_WriteTrackingLogs", new object[0]);
                flag2 = false;
                flag3 = false;
                string itemSpec = null;
                foreach (ITaskItem item2 in this.tlogFiles)
                {
                    FileTracker.LogMessage(this.Log, MessageImportance.Low, "\t{0}", new object[] { item2.ItemSpec });
                    try
                    {
                        using (StreamReader reader = File.OpenText(item2.ItemSpec))
                        {
                            string key = reader.ReadLine();
                            while (key != null)
                            {
                                if (key.Length == 0)
                                {
                                    flag2    = true;
                                    itemSpec = item2.ItemSpec;
                                    goto Label_0305;
                                }
                                if (key[0] == '^')
                                {
                                    key = key.Substring(1);
                                    if (key.Length == 0)
                                    {
                                        flag2    = true;
                                        itemSpec = item2.ItemSpec;
                                    }
                                    else
                                    {
                                        Dictionary <string, DateTime> dictionary;
                                        if (!this.dependencyTable.TryGetValue(key, out dictionary))
                                        {
                                            dictionary = new Dictionary <string, DateTime>(StringComparer.OrdinalIgnoreCase);
                                            this.dependencyTable.Add(key, dictionary);
                                        }
                                        do
                                        {
                                            key = reader.ReadLine();
                                            if (key != null)
                                            {
                                                if (key.Length == 0)
                                                {
                                                    flag2    = true;
                                                    itemSpec = item2.ItemSpec;
                                                    break;
                                                }
                                                if ((((key[0] != '^') && (key[0] != '#')) && !dictionary.ContainsKey(key)) && (FileTracker.FileIsUnderPath(key, path) || !FileTracker.FileIsExcludedFromDependencies(key)))
                                                {
                                                    DateTime lastWriteTimeUtc = NativeMethods.GetLastWriteTimeUtc(key);
                                                    dictionary.Add(key, lastWriteTimeUtc);
                                                }
                                            }
                                        }while ((key != null) && (key[0] != '^'));
                                        if (!flag2)
                                        {
                                            continue;
                                        }
                                    }
                                    goto Label_0305;
                                }
                                key = reader.ReadLine();
                            }
                        }
                    }
                    catch (Exception exception2)
                    {
                        if (ExceptionHandling.NotExpectedException(exception2))
                        {
                            throw;
                        }
                        FileTracker.LogWarningWithCodeFromResources(this.Log, "Tracking_RebuildingDueToInvalidTLog", new object[] { exception2.Message });
                        break;
                    }
Label_0305:
                    if (flag2)
                    {
                        FileTracker.LogWarningWithCodeFromResources(this.Log, "Tracking_RebuildingDueToInvalidTLogContents", new object[] { itemSpec });
                        break;
                    }
                }
            }
            else
            {
                FileTracker.LogMessageFromResources(this.Log, MessageImportance.Low, "Tracking_TrackingLogNotAvailable", new object[0]);
                lock (DependencyTableCache.DependencyTable)
                {
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                }
                return;
            }
            lock (DependencyTableCache.DependencyTable)
            {
                if (flag2 || flag3)
                {
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                    this.dependencyTable = new Dictionary <string, Dictionary <string, DateTime> >(StringComparer.OrdinalIgnoreCase);
                }
                else
                {
                    DependencyTableCache.DependencyTable[tLogRootingMarker] = new DependencyTableCacheEntry(this.tlogFiles, this.dependencyTable);
                }
            }
        }
예제 #9
0
        /// <summary>
        /// Construct our dependency table for our source files
        /// </summary>
        private void ConstructFileTable()
        {
            string tLogRootingMarker = null;

            try
            {
                // construct a rooting marker from the tlog files
                tLogRootingMarker = DependencyTableCache.FormatNormalizedTlogRootingMarker(_tlogFiles);
            }
            catch (ArgumentException e)
            {
                FileTracker.LogWarningWithCodeFromResources(_log, "Tracking_RebuildingDueToInvalidTLog", e.Message);
                return;
            }
            if (!_tlogsAvailable)
            {
                lock (DependencyTableCache.DependencyTable)
                {
                    // The tracking logs are not available, they may have been deleted at some point.
                    // Be safe and remove any references from the cache.
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }
                }
                return;
            }

            DependencyTableCacheEntry cachedEntry = null;

            lock (DependencyTableCache.DependencyTable)
            {
                // Look in the dependency table cache to see if its available and up to date
                cachedEntry = DependencyTableCache.GetCachedEntry(tLogRootingMarker);
            }

            // We have an up to date cached entry
            if (cachedEntry != null)
            {
                _dependencyTable = (IDictionary <string, DateTime>)cachedEntry.DependencyTable;

                // We may have stored the dependency table in the cache, but all the other information
                // (newest file time, number of missing files, etc.) has been reset to default.  Refresh
                // the data.
                this.UpdateFileEntryDetails();

                // Log information about what we're using
                FileTracker.LogMessageFromResources(_log, MessageImportance.Low, "Tracking_TrackingCached");
                foreach (ITaskItem tlogItem in cachedEntry.TlogFiles)
                {
                    FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogItem.ItemSpec);
                }
                return;
            }

            FileTracker.LogMessageFromResources(_log, MessageImportance.Low, "Tracking_TrackingLogs");
            // Now we need to construct the rest of the table from the TLOG files
            // If there are any errors in the tlogs, we want to warn, stop parsing tlogs, and empty
            // out the dependency table, essentially forcing a rebuild.
            bool   encounteredInvalidTLogContents = false;
            bool   exceptionCaught = false;
            string invalidTLogName = null;

            foreach (ITaskItem tlogFileName in _tlogFiles)
            {
                try
                {
                    FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogFileName.ItemSpec);

                    DateTime tlogLastWriteTimeUtc = NativeMethods.GetLastWriteTimeUtc(tlogFileName.ItemSpec);
                    if (tlogLastWriteTimeUtc > _newestTLogTimeUtc)
                    {
                        _newestTLogTimeUtc  = tlogLastWriteTimeUtc;
                        _newestTLogFileName = tlogFileName.ItemSpec;
                    }

                    using (StreamReader tlog = File.OpenText(tlogFileName.ItemSpec))
                    {
                        string tlogEntry = tlog.ReadLine();

                        while (tlogEntry != null)
                        {
                            if (tlogEntry.Length == 0) // empty lines are a sign that something has gone wrong
                            {
                                encounteredInvalidTLogContents = true;
                                invalidTLogName = tlogFileName.ItemSpec;
                                break;
                            }
                            // Preprocessing for the line entry
                            else if (tlogEntry[0] == '#') // a comment marker should be skipped
                            {
                                tlogEntry = tlog.ReadLine();
                                continue;
                            }
                            else if (tlogEntry[0] == '^' && TreatRootMarkersAsEntries) // This is a rooting record, and we should keep it
                            {
                                tlogEntry = tlogEntry.Substring(1);

                                if (tlogEntry.Length == 0)
                                {
                                    encounteredInvalidTLogContents = true;
                                    invalidTLogName = tlogFileName.ItemSpec;
                                    break;
                                }
                            }
                            else if (tlogEntry[0] == '^') // root marker is not being treated as an entry, skip it
                            {
                                tlogEntry = tlog.ReadLine();
                                continue;
                            }

                            // If we haven't seen this file before, then record it
                            if (!_dependencyTable.ContainsKey(tlogEntry))
                            {
                                // It may be that this is one of the locations that we should ignore
                                if (!FileTracker.FileIsExcludedFromDependencies(tlogEntry))
                                {
                                    RecordEntryDetails(tlogEntry, true);
                                }
                            }
                            tlogEntry = tlog.ReadLine();
                        }
                    }
                }
                catch (Exception e) when(ExceptionHandling.IsIoRelatedException(e))
                {
                    FileTracker.LogWarningWithCodeFromResources(_log, "Tracking_RebuildingDueToInvalidTLog", e.Message);
                    break;
                }

                if (encounteredInvalidTLogContents)
                {
                    FileTracker.LogWarningWithCodeFromResources(_log, "Tracking_RebuildingDueToInvalidTLogContents", invalidTLogName);
                    break;
                }
            }

            lock (DependencyTableCache.DependencyTable)
            {
                // There were problems with the tracking logs -- we've already warned or errored; now we want to make
                // sure that we essentially force a rebuild of this particular root.
                if (encounteredInvalidTLogContents || exceptionCaught)
                {
                    if (DependencyTableCache.DependencyTable.ContainsKey(tLogRootingMarker))
                    {
                        DependencyTableCache.DependencyTable.Remove(tLogRootingMarker);
                    }

                    _dependencyTable = new Dictionary <string, DateTime>(StringComparer.OrdinalIgnoreCase);
                }
                else
                {
                    // Record the newly built dependency table in the cache
                    DependencyTableCache.DependencyTable[tLogRootingMarker] = new DependencyTableCacheEntry(_tlogFiles, (IDictionary)_dependencyTable);
                }
            }
        }