/// <summary> /// Creates a new change tracker in the <see cref="FileChangeTrackingState.BuildingInitialChangeTrackingSet"/> state. /// The caller may then add tracking for full set of files of interest, for later re-use by /// <see cref="ResumeTrackingChanges(LoggingContext,BuildXL.Utilities.FileEnvelopeId,VolumeMap,IChangeJournalAccessor,FileChangeTrackingSet,string)"/>. /// </summary> public static FileChangeTracker StartTrackingChanges( LoggingContext loggingContext, VolumeMap volumeMap, IChangeJournalAccessor journal, string buildEngineFingerprint, FileEnvelopeId?correlatedId = default) { Contract.Requires(loggingContext != null); Contract.Requires(volumeMap != null); Contract.Requires(journal != null); Contract.Ensures(Contract.Result <FileChangeTracker>().TrackingState == FileChangeTrackingState.BuildingInitialChangeTrackingSet); var tracker = new FileChangeTracker( loggingContext, correlatedId ?? FileEnvelopeId.Create(), FileChangeTrackingState.BuildingInitialChangeTrackingSet, volumeMap, journal, FileChangeTrackingSet.CreateForAllCapableVolumes(loggingContext, volumeMap, journal), buildEngineFingerprint); foreach (var gvfsProjectionFile in volumeMap.GvfsProjections) { var maybeTracking = tracker.TryProbeAndTrackPath(gvfsProjectionFile); if (!maybeTracking.Succeeded) { Logger.Log.TrackChangesToGvfsProjectionFailed(loggingContext, gvfsProjectionFile, maybeTracking.Failure.DescribeIncludingInnerFailures()); } } return(tracker); }
private FileChangeTracker( LoggingContext loggingContext, FileEnvelopeId fileEnvelopeId, FileChangeTrackingState initialState, VolumeMap volumeMap, IChangeJournalAccessor journal, FileChangeTrackingSet currentChangeTrackingSet, string buildEngineFingerprint) { Contract.Requires(loggingContext != null); Contract.Requires(fileEnvelopeId.IsValid); Contract.Requires( initialState == FileChangeTrackingState.BuildingInitialChangeTrackingSet || initialState == FileChangeTrackingState.TrackingChanges); Contract.Requires(volumeMap != null); Contract.Requires(journal != null); Contract.Requires(currentChangeTrackingSet != null); FileEnvelopeId = fileEnvelopeId; m_loggingContext = loggingContext; m_volumeMap = volumeMap; m_journal = journal; m_changeTrackingSet = currentChangeTrackingSet; m_trackingStateValue = (int)initialState; Counters = m_changeTrackingSet.Counters; m_buildEngineFingerprint = buildEngineFingerprint; }
private FileChangeTracker(LoggingContext loggingContext) { Contract.Requires(loggingContext != null); m_loggingContext = loggingContext; m_volumeMap = null; m_journal = null; m_changeTrackingSet = null; m_trackingStateValue = (int)FileChangeTrackingState.DisabledSinceTrackingIsIncomplete; Counters = new CounterCollection <FileChangeTrackingCounter>(); m_buildEngineFingerprint = null; }
public void StartTracking() { var loggingContext = new LoggingContext("JournalTesting", "Dummy"); VolumeMap volumeMap = JournalUtils.TryCreateMapOfAllLocalVolumes(loggingContext); XAssert.IsNotNull(volumeMap); var maybeJournal = JournalUtils.TryGetJournalAccessorForTest(volumeMap); XAssert.IsTrue(maybeJournal.Succeeded); m_journal = maybeJournal.Result; m_changeTracker = FileChangeTrackingSet.CreateForAllCapableVolumes( loggingContext, volumeMap, m_journal); }
/// <summary> /// Creates a new change tracker in the <see cref="FileChangeTrackingState.BuildingInitialChangeTrackingSet"/> state. /// The caller may then add tracking for full set of files of interest, for later re-use by /// <see cref="ResumeTrackingChanges(LoggingContext,BuildXL.Utilities.FileEnvelopeId,VolumeMap,IChangeJournalAccessor,FileChangeTrackingSet,string)"/>. /// </summary> public static FileChangeTracker StartTrackingChanges( LoggingContext loggingContext, VolumeMap volumeMap, IChangeJournalAccessor journal, string buildEngineFingerprint, FileEnvelopeId?correlatedId = default) { Contract.Requires(loggingContext != null); Contract.Requires(volumeMap != null); Contract.Requires(journal != null); Contract.Ensures(Contract.Result <FileChangeTracker>().TrackingState == FileChangeTrackingState.BuildingInitialChangeTrackingSet); return(new FileChangeTracker( loggingContext, correlatedId ?? FileEnvelopeId.Create(), FileChangeTrackingState.BuildingInitialChangeTrackingSet, volumeMap, journal, FileChangeTrackingSet.CreateForAllCapableVolumes(loggingContext, volumeMap, journal), buildEngineFingerprint)); }
/// <summary> /// Creates a new change tracker in the <see cref="FileChangeTrackingState.TrackingChanges"/> state. /// The caller may query for new changes since the tracking set was last checkpointed and persisted, and may track additional files. /// </summary> private static FileChangeTracker ResumeTrackingChanges( LoggingContext loggingContext, FileEnvelopeId fileEnvelopeId, VolumeMap volumeMap, IChangeJournalAccessor journal, FileChangeTrackingSet previousChangeTrackingSet, string buildEngineFingerprint) { Contract.Requires(loggingContext != null); Contract.Requires(volumeMap != null); Contract.Requires(journal != null); Contract.Requires(previousChangeTrackingSet != null); Contract.Requires(fileEnvelopeId.IsValid); return(new FileChangeTracker( loggingContext, fileEnvelopeId, FileChangeTrackingState.TrackingChanges, volumeMap, journal, previousChangeTrackingSet, buildEngineFingerprint)); }
public static LoadingTrackerResult TryLoad( LoggingContext loggingContext, string path, VolumeMap volumeMap, IChangeJournalAccessor journal, string buildEngineFingerprint, bool loadForAllCapableVolumes = true) { Contract.Requires(loggingContext != null); Contract.Requires(!loadForAllCapableVolumes || volumeMap != null); Contract.Requires(!loadForAllCapableVolumes || journal != null); Stopwatch stopwatch = Stopwatch.StartNew(); SafeFileHandle handle; OpenFileResult result = FileUtilities.TryCreateOrOpenFile( path, FileDesiredAccess.GenericRead, FileShare.Read | FileShare.Delete, FileMode.Open, // Ok to evict the file from standby since the file will be overwritten and never reread from disk after this point. FileFlagsAndAttributes.FileFlagSequentialScan, out handle); if (result.Succeeded) { Contract.Assume(handle != null); Contract.Assume(!handle.IsInvalid); using (handle) { using (var stream = new FileStream(handle, FileAccess.Read)) { FileEnvelopeId fileEnvelopeId; try { fileEnvelopeId = FileEnvelope.ReadHeader(stream); } catch (BuildXLException e) { return(LoadingTrackerResult.FailBadFormatMarker(e.Message)); } try { return(ExceptionUtilities.HandleRecoverableIOException( () => { using (var reader = new BuildXLReader(debug: false, stream: stream, leaveOpen: true)) { bool wasTrackerDisabled = reader.ReadBoolean(); if (wasTrackerDisabled) { return LoadingTrackerResult.FailPriorTrackerDisabled(); } var previousFingerprint = reader.ReadNullable(r => r.ReadString()); // only check for fingerprints match if the supplied fingerprint is valid // this is to support special cases where we might want to load ChangeTracker // regardless of the previously stored fingerprint value if (buildEngineFingerprint != null && !string.Equals(previousFingerprint, buildEngineFingerprint, StringComparison.Ordinal)) { return LoadingTrackerResult.FailBuildEngineFingerprintMismatch(); } return FileChangeTrackingSet.TryLoad( loggingContext, fileEnvelopeId, reader, volumeMap, journal, stopwatch, loadForAllCapableVolumes); } }, ex => { throw new BuildXLException(ex.Message); })); } catch (Exception e) { // Catch any exception. Failure in loading FileChangeTracker should not // cause build break, or worse, make people stuck on erroneous state. // In such a case, BuildXL simply has to start tracking from scratch. return(LoadingTrackerResult.FailLoadException(e.GetLogEventMessage())); } } } } Contract.Assume(handle == null); return(LoadingTrackerResult.FailTrackingSetCannotBeOpened(result.CreateFailureForError().DescribeIncludingInnerFailures())); }