private static void TestInternalCheck() { FileState.InternalCheck(true, "This InternalCheck should not fire", new object[0]); try { FileState.InternalCheck(false, "This InternalCheck should fire", new object[0]); DiagCore.RetailAssert(false, "Should have thrown FileStateInternalErrorException", new object[0]); } catch (FileStateInternalErrorException) { } }
// Token: 0x06001C63 RID: 7267 RVA: 0x0007CAFC File Offset: 0x0007ACFC public void InternalCheckLogfileSignature() { lock (this) { if (0L != this.LowestGenerationPresent) { FileState.InternalCheck(this.LogfileSignature != null, "Logfiles are present, but LogfileSignature is not set", new object[0]); } if (0L != this.LowestGenerationRequired) { FileState.InternalCheck(this.LogfileSignature != null, "Logfiles are required, but LogfileSignature is not set", new object[0]); } } }
// Token: 0x06001C62 RID: 7266 RVA: 0x0007C8F8 File Offset: 0x0007AAF8 public void InternalCheck() { lock (this) { FileState.InternalCheck(this.m_lowestGenerationPresent <= this.m_highestGenerationPresent, "LowestGenerationPresent > HighestGenerationPresent", new object[0]); FileState.InternalCheck(this.m_lowestGenerationRequired <= this.m_highestGenerationRequired, "LowestGenerationRequired > HighestGenerationRequired", new object[0]); if (0L == this.m_lowestGenerationPresent) { FileState.InternalCheck(0L == this.m_highestGenerationPresent, "LowestGenerationPresent is 0, but HighestGenerationPresent is set", new object[0]); } else { FileState.InternalCheck(0L != this.m_highestGenerationPresent, "LowestGenerationPresent is set, but HighestGenerationPresent is 0", new object[0]); } if (0L == this.m_lowestGenerationRequired) { FileState.InternalCheck(0L == this.m_highestGenerationRequired, "LowestGenerationRequired is 0, but HighestGenerationRequired is set", new object[0]); } else { FileState.InternalCheck(0L != this.m_highestGenerationRequired, "LowestGenerationRequired is set, but HighestGenerationRequired is 0", new object[0]); } if (this.m_consistentDatabase) { FileState.InternalCheck(this.m_highestGenerationRequired == this.m_lowestGenerationRequired, "ConsistentDatabase is true, but HighestGenerationRequired != LowestGenerationRequired", new object[0]); } if (this.m_highestGenerationRequired != this.m_lowestGenerationRequired) { FileState.InternalCheck(!this.m_consistentDatabase, "HighestGenerationRequired != LowestGenerationRequired but ConsistentDatabase is true", new object[0]); } if (this.m_latestFullBackupTime != null) { FileState.InternalCheck(this.m_lastGenerationBackedUp > 0L, "m_latestFullBackupTime is set, but m_lastGenerationBackedUp is not set", new object[0]); } if (this.m_latestIncrementalBackupTime != null) { FileState.InternalCheck(this.m_lastGenerationBackedUp > 0L, "m_latestIncrementalBackupTime is set, but m_lastGenerationBackedUp is not set", new object[0]); FileState.InternalCheck(this.m_latestFullBackupTime != null, "m_latestIncrementalBackupTime is set, but m_latestFullBackupTime is not set", new object[0]); } if (this.m_latestDifferentialBackupTime != null) { FileState.InternalCheck(this.m_lastGenerationBackedUp > 0L, "m_latestDifferentialBackupTime is set, but m_lastGenerationBackedUp is not set", new object[0]); FileState.InternalCheck(this.m_latestFullBackupTime != null, "m_latestDifferentialBackupTime is set, but m_latestFullBackupTime is not set", new object[0]); } } }
// Token: 0x06001C65 RID: 7269 RVA: 0x0007CBD4 File Offset: 0x0007ADD4 public void SetLowestAndHighestGenerationsPresent(long lowestGenerationPresent, long highestGenerationPresent) { FileState.InternalCheck(lowestGenerationPresent <= highestGenerationPresent, "lowestGenerationPresent > highestGenerationPresent", new object[0]); if (lowestGenerationPresent == 0L) { FileState.InternalCheck(highestGenerationPresent == 0L, "Highest gen must be 0 when low gen is 0", new object[0]); } if (highestGenerationPresent == 0L) { FileState.InternalCheck(lowestGenerationPresent == 0L, "Lowest gen must be 0 when hi gen is 0", new object[0]); } lock (this) { this.InternalCheck(); this.m_lowestGenerationPresent = lowestGenerationPresent; this.m_highestGenerationPresent = highestGenerationPresent; this.InternalCheck(); } }
// Token: 0x06001C67 RID: 7271 RVA: 0x0007CCD4 File Offset: 0x0007AED4 public void SetLowestAndHighestGenerationsRequired(long lowestGenerationRequired, long highestGenerationRequired, bool databaseIsConsistent) { FileState.InternalCheck(lowestGenerationRequired >= 0L, "lowestGenerationRequired should be greater than 0 but we got {0}", new object[] { lowestGenerationRequired }); FileState.InternalCheck(highestGenerationRequired >= 0L, "highestGenerationRequired should be greater than 0 but we got {0}", new object[] { highestGenerationRequired }); FileState.InternalCheck(lowestGenerationRequired <= highestGenerationRequired, "lowestGenerationRequired > highestGenerationRequired", new object[0]); FileState.InternalCheck(!databaseIsConsistent || lowestGenerationRequired == highestGenerationRequired, "lowestGenerationRequired != highestGenerationRequired, but the database is consistent", new object[0]); lock (this) { this.InternalCheck(); this.m_lowestGenerationRequired = lowestGenerationRequired; this.m_highestGenerationRequired = highestGenerationRequired; this.m_consistentDatabase = databaseIsConsistent; this.InternalCheck(); } }
// Token: 0x06001D3E RID: 7486 RVA: 0x00083E24 File Offset: 0x00082024 public LogInspector(IPerfmonCounters perfmonCounters, IReplayConfiguration replayConfig, string logfileBaseName, string logfileSuffix, string replayDir, FileState fileState, ILogTruncater logTruncater, ISetBroken setBroken, ISetGeneration setGeneration, IReplicaProgress replicaProgress, NetworkPath netPath, bool runningAcll) : base(replayConfig.LogInspectorPath, logfileBaseName, 0L, logfileSuffix, setBroken, replicaProgress) { this.Config = replayConfig; this.m_logTruncater = logTruncater; this.m_replayDir = replayDir; this.m_fileState = fileState; this.m_setGeneration = setGeneration; this.m_logVerifier = new LogVerifier(logfileBaseName); ExTraceGlobals.LogInspectorTracer.TraceDebug((long)this.GetHashCode(), "LogInspector initialized - inspectDir = {0}, logfileBaseName = {1}, replayDir = {2}, fileState = {3}", new object[] { replayConfig.LogInspectorPath, logfileBaseName, replayDir, fileState }); ExTraceGlobals.PFDTracer.TracePfd((long)this.GetHashCode(), "LogInspector initialized - inspectDir = {0}, logfileBaseName = {1}, replayDir = {2}, fileState = {3}", new object[] { replayConfig.LogInspectorPath, logfileBaseName, replayDir, fileState }); this.Config.ReplayState.InspectorGenerationNumber = this.m_fileState.HighestGenerationPresent; this.m_logSource = LogSource.Construct(replayConfig, perfmonCounters, netPath, LogSource.GetLogShipTimeoutInMsec(runningAcll)); if (0L != this.m_fileState.HighestGenerationPresent) { this.m_logContinuityChecker.Initialize(this.m_fileState.HighestGenerationPresent, this.Config.DestinationLogPath, this.Config.LogFilePrefix, logfileSuffix); } }
// Token: 0x06001D3D RID: 7485 RVA: 0x00083DFC File Offset: 0x00081FFC public LogInspector(IPerfmonCounters perfmonCounters, IReplayConfiguration replayConfig, string logfileBaseName, string logfileSuffix, string replayDir, FileState fileState, ILogTruncater logTruncater, ISetBroken setBroken, ISetGeneration setGeneration, IReplicaProgress replicaProgress, NetworkPath netPath) : this(perfmonCounters, replayConfig, logfileBaseName, logfileSuffix, replayDir, fileState, logTruncater, setBroken, setGeneration, replicaProgress, netPath, false) { }
// Token: 0x06001D52 RID: 7506 RVA: 0x00084580 File Offset: 0x00082780 private static bool CheckLogHeaderInternal(long logfileNumber, string logfileInspect, FileState fileState, LogContinuityChecker continuityChecker, out LocalizedString error) { error = LocalizedString.Empty; JET_LOGINFOMISC jet_LOGINFOMISC; long logfileGeneration = EseHelper.GetLogfileGeneration(logfileInspect, out jet_LOGINFOMISC); if (0L == logfileNumber && 0L != fileState.HighestGenerationPresent && fileState.HighestGenerationPresent + 1L != logfileGeneration) { ExTraceGlobals.LogInspectorTracer.TraceError <string, long, long>(0L, "Inspection of logfile {0} detected corruption (generation number {1} mismatch with highest logfile present {2})", logfileInspect, logfileGeneration, fileState.HighestGenerationPresent); error = ReplayStrings.LogInspectorE00OutOfSequence(logfileInspect, logfileGeneration, fileState.HighestGenerationPresent); return(false); } if (logfileNumber != 0L && logfileNumber != logfileGeneration) { ExTraceGlobals.LogInspectorTracer.TraceError <string, long>(0L, "Inspection of logfile {0} detected corruption (generation number {1} mismatch)", logfileInspect, logfileGeneration); error = ReplayStrings.LogInspectorGenerationMismatch(logfileInspect, logfileGeneration, logfileNumber); return(false); } if (fileState.LogfileSignature != null) { if (!jet_LOGINFOMISC.signLog.Equals(fileState.LogfileSignature.Value)) { ExTraceGlobals.LogInspectorTracer.TraceError <string, JET_SIGNATURE, JET_SIGNATURE>(0L, "Inspection of logfile {0} detected a signature mismatch (signature is {1}, expected {2})", logfileInspect, jet_LOGINFOMISC.signLog, fileState.LogfileSignature.Value); error = ReplayStrings.LogInspectorSignatureMismatch(logfileInspect, logfileGeneration); return(false); } } else { ExTraceGlobals.LogInspectorTracer.TraceDebug <JET_SIGNATURE, string>(0L, "Setting logfile signature to {0} from logfile {1}", jet_LOGINFOMISC.signLog, logfileInspect); fileState.LogfileSignature = new JET_SIGNATURE?(jet_LOGINFOMISC.signLog); } if (!continuityChecker.Examine(jet_LOGINFOMISC, logfileInspect, out error)) { ExTraceGlobals.LogInspectorTracer.TraceError <string, LocalizedString>(0L, "Inspection of logfile {0} detected discontinuity: {1}", logfileInspect, error); return(false); } return(true); }
// Token: 0x06001D4B RID: 7499 RVA: 0x000843F4 File Offset: 0x000825F4 internal static bool VerifyLogStatic(long logfileNumber, LogSource logSource, string logfileInspect, bool fRecopyOnFailure, FileState filestate, LogVerifier logVerifier, LogContinuityChecker continuityChecker, LogInspector.CheckStopDelegate checkStopPending, out LocalizedString error) { ulong num = fRecopyOnFailure ? 3UL : 1UL; bool flag = false; bool flag2 = false; error = LocalizedString.Empty; for (ulong num2 = 0UL; num2 < num; num2 += 1UL) { bool flag3 = false; if (flag2 && fRecopyOnFailure) { LogInspector.RecopyCorruptLog(logfileNumber, logSource, logfileInspect); flag3 = true; } checkStopPending(); EsentErrorException ex = logVerifier.Verify(logfileInspect); if (ex != null) { ExTraceGlobals.LogInspectorTracer.TraceError <string, EsentErrorException>(0L, "Inspection of logfile {0} failed: {1}", logfileInspect, ex); error = new LocalizedString(ex.Message); if (!(ex is EsentFileAccessDeniedException)) { flag2 = true; LogInspector.ReportCorruptLog(logfileInspect, error); } } else { flag2 = false; checkStopPending(); flag = LogInspector.CheckLogHeader(logfileNumber, logfileInspect, filestate, continuityChecker, out error); if (!flag) { LogInspector.ReportCorruptLog(logfileInspect, error); } else { if (flag3) { ReplayEventLogConstants.Tuple_InspectorFixedCorruptLog.LogEvent(logfileInspect, new object[] { logfileInspect }); break; } break; } } } return(flag); }
// Token: 0x06001D49 RID: 7497 RVA: 0x00084374 File Offset: 0x00082574 internal static bool VerifyLogTask(long logfileNumber, string logfileInspect, FileState fileState, LogVerifier logVerifier, LogContinuityChecker continuityChecker, out LocalizedString error) { error = LocalizedString.Empty; if (logVerifier == null) { throw new ArgumentNullException("logVerifier"); } EsentErrorException ex = logVerifier.Verify(logfileInspect); if (ex != null) { error = new LocalizedString(ex.Message); return(false); } return(LogInspector.CheckLogHeaderInternal(logfileNumber, logfileInspect, fileState, continuityChecker, out error)); }
// Token: 0x06001D48 RID: 7496 RVA: 0x0008430C File Offset: 0x0008250C internal static bool CheckLogHeader(long logfileNumber, string logfileInspect, FileState fileState, LogContinuityChecker continuityChecker, out LocalizedString error) { error = LocalizedString.Empty; bool result; try { result = LogInspector.CheckLogHeaderInternal(logfileNumber, logfileInspect, fileState, continuityChecker, out error); } catch (EsentErrorException ex) { ReplayEventLogConstants.Tuple_IsamException.LogEvent(logfileInspect, new object[] { "unknown", ex.Message, logfileInspect }); result = false; } return(result); }
// Token: 0x06000A21 RID: 2593 RVA: 0x0002F2C0 File Offset: 0x0002D4C0 public static void MoveLogFiles(ReplayConfiguration config, FileState fileState, ISetBroken setBroken, long corruptLogGen) { string text = Path.Combine(config.E00LogBackupPath, "SkippedLogs"); Exception ex = DirectoryOperations.TryCreateDirectory(text); if (ex != null) { setBroken.SetBroken(FailureTag.Configuration, ReplayEventLogConstants.Tuple_FailedToCreateDirectory, ex, new string[] { text, ex.ToString() }); return; } string currentDateString = FileOperations.GetCurrentDateString(); string text2 = Path.Combine(text, currentDateString); ex = DirectoryOperations.TryCreateDirectory(text2); if (ex != null) { setBroken.SetBroken(FailureTag.Configuration, ReplayEventLogConstants.Tuple_FailedToCreateDirectory, ex, new string[] { text2, ex.ToString() }); return; } string destinationLogPath = config.DestinationLogPath; string text3 = string.Empty; string path = string.Empty; try { ReplayEventLogConstants.Tuple_MovingFilesToRestartLogStream.LogEvent(null, new object[] { config.DatabaseName, EseHelper.MakeLogfileName(config.LogFilePrefix, config.LogFileSuffix, corruptLogGen), text2 }); foreach (string text4 in Directory.GetFiles(destinationLogPath, "*." + config.LogExtension)) { text3 = text4; path = Path.GetFileName(text4); long logfileGenerationFromFilePath = EseHelper.GetLogfileGenerationFromFilePath(text4, config.LogFilePrefix); if (logfileGenerationFromFilePath >= fileState.LowestGenerationRequired) { ExTraceGlobals.ReplicaInstanceTracer.TraceError <string>(0L, "MoveLogFiles(): Cannot move logfile '{0}' because it is required by the database.", text4); } else { File.Move(text4, Path.Combine(text2, path)); } } foreach (string text5 in Directory.GetFiles(destinationLogPath, "*.jsl")) { text3 = text5; path = Path.GetFileName(text5); File.Move(text5, Path.Combine(text2, path)); } ExTraceGlobals.ReplicaInstanceTracer.TraceError <string>(0L, "Moved log files successfully from '{0}'", config.DestinationLogPath); } catch (IOException ex2) { ExTraceGlobals.ReplicaInstanceTracer.TraceError <string, string, IOException>(0L, "Moving file '{0}' to '{1}' failed with exception: {2}", text3, text2, ex2); setBroken.SetBroken(ReplicaInstance.IOExceptionToFailureTag(ex2), ReplayEventLogConstants.Tuple_CouldNotDeleteLogFile, ex2, new string[] { text3, ex2.ToString() }); } catch (UnauthorizedAccessException ex3) { ExTraceGlobals.ReplicaInstanceTracer.TraceError <string, string, UnauthorizedAccessException>(0L, "Moving file '{0}' to '{1}' failed with exception: {2}", text3, text2, ex3); setBroken.SetBroken(FailureTag.AlertOnly, ReplayEventLogConstants.Tuple_CouldNotDeleteLogFile, ex3, new string[] { text3, ex3.ToString() }); } }
// Token: 0x06001C8A RID: 7306 RVA: 0x0007D784 File Offset: 0x0007B984 internal static void InternalTest() { FileState.TestInternalCheck(); FileState fileState = new FileState(); fileState.AssertMembersAreZero(); fileState.SetLowestAndHighestGenerationsPresent(2L, 3L); fileState.SetLowestAndHighestGenerationsRequired(8L, 9L, false); fileState.LastGenerationBackedUp = 1L; fileState.CheckpointGeneration = 7L; DiagCore.RetailAssert(!fileState.ConsistentDatabase, "ConsistentDatabase is {0}, expected {1}", new object[] { fileState.ConsistentDatabase, false }); DiagCore.RetailAssert(2L == fileState.LowestGenerationPresent, "LowestGenerationPresent is {0}, expected {1}", new object[] { fileState.LowestGenerationPresent, 2 }); DiagCore.RetailAssert(3L == fileState.HighestGenerationPresent, "HighestGenerationPresent is {0}, expected {1}", new object[] { fileState.HighestGenerationPresent, 3 }); DiagCore.RetailAssert(8L == fileState.LowestGenerationRequired, "LowestGenerationRequired is {0}, expected {1}", new object[] { fileState.LowestGenerationRequired, 8 }); DiagCore.RetailAssert(9L == fileState.HighestGenerationRequired, "HighestGenerationRequired is {0}, expected {1}", new object[] { fileState.HighestGenerationRequired, 9 }); DiagCore.RetailAssert(1L == fileState.LastGenerationBackedUp, "LastGenerationBackedUp is {0}, expected {1}", new object[] { fileState.LastGenerationBackedUp, 1 }); DiagCore.RetailAssert(7L == fileState.CheckpointGeneration, "CheckpointGeneration is {0}, expected {1}", new object[] { fileState.CheckpointGeneration, 7 }); fileState.Reset(); fileState.AssertMembersAreZero(); DiagCore.RetailAssert(fileState.RequiredLogfilesArePresent(), "RequiredLogfilesArePresent", new object[0]); fileState.SetLowestAndHighestGenerationsPresent(18L, 21L); fileState.SetLowestAndHighestGenerationsRequired(18L, 21L, false); DiagCore.RetailAssert(fileState.RequiredLogfilesArePresent(), "RequiredLogfilesArePresent", new object[0]); fileState.Reset(); fileState.SetLowestAndHighestGenerationsPresent(18L, 21L); fileState.SetLowestAndHighestGenerationsRequired(19L, 20L, false); DiagCore.RetailAssert(fileState.RequiredLogfilesArePresent(), "RequiredLogfilesArePresent", new object[0]); fileState.Reset(); fileState.SetLowestAndHighestGenerationsPresent(18L, 21L); fileState.SetLowestAndHighestGenerationsRequired(19L, 22L, false); DiagCore.RetailAssert(!fileState.RequiredLogfilesArePresent(), "RequiredLogfilesArePresent", new object[0]); fileState.Reset(); fileState.SetLowestAndHighestGenerationsPresent(18L, 21L); fileState.SetLowestAndHighestGenerationsRequired(17L, 20L, false); DiagCore.RetailAssert(fileState.RequiredLogfilesArePresent(), "RequiredLogfilesArePresent", new object[0]); fileState.Reset(); }
// Token: 0x06001D69 RID: 7529 RVA: 0x000850F4 File Offset: 0x000832F4 public void CheckForDivergence(FileState fileState) { this.m_logSource = LogSource.Construct(this.Config, null, null, LogSource.GetLogShipTimeoutInMsec(false)); if (0L == fileState.HighestGenerationPresent || fileState.HighestGenerationPresent < fileState.HighestGenerationRequired) { LogRepair.Tracer.TraceError <string, long>((long)this.GetHashCode(), "CheckForDivergence({0}): failed with HighestGenerationPresent 0x{1:X}", this.Config.DisplayName, fileState.HighestGenerationPresent); throw new LogRepairNotPossibleException(ReplayStrings.LogRepairNotPossibleInsuffientToCheckDivergence); } long num = fileState.HighestGenerationPresent; string text = Path.Combine(this.Config.DestinationLogPath, this.Config.LogFilePrefix) + "." + this.Config.LogExtension; bool flag = false; string text2; if (File.Exists(text)) { flag = true; num += 1L; text2 = text; } else { text2 = this.Config.BuildFullLogfileName(num); } long num2 = -1L; Exception ex = null; try { num2 = this.m_logSource.QueryEndOfLog(); } catch (NetworkRemoteException ex2) { ex = ex2; } catch (NetworkTransportException ex3) { ex = ex3; } if (ex != null) { throw new LogRepairTransientException(ex.Message, ex); } if (num2 < num) { LogRepair.Tracer.TraceError <string, long>((long)this.GetHashCode(), "CheckForDivergence({0}): failed with HighestGenerationPresent 0x{1:X}", this.Config.DisplayName, fileState.HighestGenerationPresent); throw new LogRepairNotPossibleException(ReplayStrings.LogRepairNotPossibleActiveIsDivergent(this.Config.SourceMachine)); } ex = this.VerifyLog(text2, num); if (ex != null) { throw new LogRepairNotPossibleException(ReplayStrings.LogRepairDivergenceCheckFailedDueToCorruptEndOfLog(text2, ex.Message), ex); } string path = this.Config.BuildShortLogfileName(num); string text3 = Path.Combine(this.m_workingPath, path); this.CopyAndVerifyFromActive(num, text3); try { if (flag) { if (!EseHelper.IsLogfileSubset(text3, text, this.m_workingPath, null, null)) { LogRepair.Tracer.TraceError <string, long>((long)this.GetHashCode(), "CheckForDivergence({0}): failed with e00 divergence at gen 0x{1}.", this.Config.DisplayName, num); throw new LogRepairNotPossibleException(ReplayStrings.LogRepairNotPossibleActiveIsDivergent(this.Config.SourceMachine)); } long num3 = num - 1L; if (num3 <= 1L) { throw new LogRepairNotPossibleException(ReplayStrings.LogRepairNotPossibleInsuffientToCheckDivergence); } string text4 = this.Config.BuildFullLogfileName(num3); this.VerifyLog(text4, num3); if (ex != null) { throw new LogRepairNotPossibleException(ReplayStrings.LogRepairDivergenceCheckFailedDueToCorruptEndOfLog(text4, ex.Message), ex); } string text5 = this.Config.BuildShortLogfileName(num3); string text6 = Path.Combine(this.m_workingPath, text5); this.CopyAndVerifyFromActive(num3, text6); Exception ex4; if (!this.IsFileBinaryEqual(text6, text4, out ex4)) { if (ex4 != null) { throw new LogRepairDivergenceCheckFailedException(text5, text6, ex4.Message, ex4); } throw new LogRepairNotPossibleException(ReplayStrings.LogRepairNotPossibleActiveIsDivergent(this.Config.SourceMachine)); } } else if (!EseHelper.IsLogfileEqual(text3, text2, this.m_workingPath, null, null)) { LogRepair.Tracer.TraceError <string, long>((long)this.GetHashCode(), "CheckForDivergence({0}): failed with divergence at gen 0x{1}.", this.Config.DisplayName, num); throw new LogRepairNotPossibleException(ReplayStrings.LogRepairNotPossibleActiveIsDivergent(this.Config.SourceMachine)); } } catch (EsentErrorException ex5) { throw new LogRepairDivergenceCheckFailedException(text2, text3, ex5.Message, ex5); } }
public static long CalculateLowestGenerationRequired(IReplayConfiguration config, FileState fileState) { long num = fileState.LowestGenerationRequired; if (!config.CircularLoggingEnabled && fileState.LastGenerationBackedUp != 0L) { num = Math.Min(num, fileState.LastGenerationBackedUp); } return(num); }