// Token: 0x06000965 RID: 2405 RVA: 0x0002C3CC File Offset: 0x0002A5CC
public static bool IsIncrementalReseedInProgress(string database)
{
JET_DBINFOMISC dbInfo;
Api.JetGetDatabaseFileInfo(database, out dbInfo, JET_DbInfo.Misc);
return(EseHelper.IsIncrementalReseedInProgress(dbInfo));
}
// Token: 0x06001BC3 RID: 7107 RVA: 0x0007766C File Offset: 0x0007586C
private bool IsIncrementalReseedNecessary(out bool e00Exists, out LocalizedString errorString)
{
e00Exists = false;
errorString = LocalizedString.Empty;
bool flag = false;
bool flag2 = false;
bool flag3 = this.m_fPerformDivergenceCheck;
string path = EseHelper.MakeLogfileName(this.m_configuration.LogFilePrefix, "." + this.m_configuration.LogExtension);
string text = Path.Combine(this.m_configuration.DestinationLogPath, path);
FileInfo fileInfo = new FileInfo(text);
if (fileInfo.Exists)
{
e00Exists = true;
flag3 = true;
ExTraceGlobals.ReplicaInstanceTracer.TraceDebug <string, string>((long)this.GetHashCode(), "AttemptCopyLastLogs.IsIncrementalReseedNecessary(): {0}: Found existing current log at '{1}'.", this.m_configuration.DisplayName, text);
string identity = this.m_configuration.Identity;
ExTraceGlobals.FaultInjectionTracer.TraceTest <string>(3880135997U, identity);
}
if (flag3)
{
ExTraceGlobals.ReplicaInstanceTracer.TraceDebug <string>((long)this.GetHashCode(), "AttemptCopyLastLogs.IsIncrementalReseedNecessary(): {0}: Now performing a divergence check...", this.m_configuration.DisplayName);
flag2 = this.AreLogFilesDivergentFromSource(out flag, out errorString);
}
fileInfo.Refresh();
e00Exists = fileInfo.Exists;
if (!flag2 && e00Exists && !flag)
{
errorString = ReplayStrings.AcllFailedCurrentLogPresent(this.m_configuration.DisplayName, text, this.m_configuration.SourceMachine);
ExTraceGlobals.ReplicaInstanceTracer.TraceDebug <string, string>((long)this.GetHashCode(), "AttemptCopyLastLogs.IsIncrementalReseedNecessary(): {0}: returning 'true' since current log '{1}' already exists.", this.m_configuration.DisplayName, text);
flag2 = true;
}
return(flag2);
}
public LogChecksummer(string basename)
{
bool flag = false;
EseHelper.GlobalInit();
this.m_disposeTracker = this.GetDisposeTracker();
this.m_instanceName = string.Format("LogChecksummer {0} {1}", basename, this.GetHashCode());
Api.JetCreateInstance(out this.m_instance, this.m_instanceName);
this.m_basename = basename;
bool jettermNeeded = true;
try
{
InstanceParameters instanceParameters = new InstanceParameters(this.Instance);
instanceParameters.Recovery = false;
instanceParameters.MaxTemporaryTables = 0;
instanceParameters.NoInformationEvent = true;
instanceParameters.BaseName = basename;
jettermNeeded = false;
Api.JetInit(ref this.m_instance);
jettermNeeded = true;
Api.JetBeginSession(this.Instance, out this.m_sesid, null, null);
this.AssertNotTerminated();
flag = true;
LogChecksummer.Tracer.TraceDebug <string, int>((long)this.GetHashCode(), "LogChecksummer created: {0}. DispTracker=0x{1:X}", this.m_instanceName, this.m_disposeTracker.GetHashCode());
}
finally
{
if (!flag)
{
this.Term(jettermNeeded);
}
}
}
// Token: 0x06001BBB RID: 7099 RVA: 0x00076E40 File Offset: 0x00075040
private void LogLossyAcll()
{
List <string> list = new List <string>(4);
string simpleName = AmServerName.GetSimpleName(this.m_configuration.SourceMachine);
string machineName = Environment.MachineName;
foreach (IADDatabaseCopy iaddatabaseCopy in this.m_configuration.Database.DatabaseCopies)
{
if (!MachineName.Comparer.Equals(iaddatabaseCopy.HostServerName, simpleName) && !MachineName.Comparer.Equals(iaddatabaseCopy.HostServerName, machineName))
{
list.Add(iaddatabaseCopy.HostServerName);
}
}
string text = string.Join(",", list.ToArray());
long generation = this.LastLogShipped;
if (this.m_logCopier.GranuleUsedAsE00)
{
generation = 0L;
}
string text2 = this.m_configuration.BuildFullLogfileName(generation);
int num = 0;
Exception ex;
EseLogRecordPosition lastLogRecordPosition = EseHelper.GetLastLogRecordPosition(text2, this.m_configuration.E00LogBackupPath, out ex);
if (lastLogRecordPosition != null)
{
num = lastLogRecordPosition.ByteOffsetToStartOfRec + lastLogRecordPosition.LogRecordLength;
}
else
{
AttemptCopyLastLogs.Tracer.TraceError <string, string>((long)this.GetHashCode(), "Failed to GetLastLogRecordPosition for '{0}': {1}", text2, (ex == null) ? "log appears empty" : ex.ToString());
}
ReplayCrimsonEvents.AcllReportedLoss2.Log <string, Guid, long, string, string, string, string, bool, string, string, string>(this.m_configuration.DatabaseName, this.m_configuration.IdentityGuid, this.NumberOfLogsLost, string.Format("0x{0:X}", this.LastLogNotified), string.Format("0x{0:X}", this.LastLogShipped), string.Format("0x{0:X}", num), string.Format("{0} UTC", this.LastLogInspectedTime.ToString("yyyy-MM-dd HH:mm:ss.fff")), this.m_logCopier.GranuleUsedAsE00, this.m_configuration.SourceMachine, text, this.m_uniqueOperationId);
}
// Token: 0x06001D19 RID: 7449 RVA: 0x00082A98 File Offset: 0x00080C98
public static bool GenerationAvailableInDirectory(DirectoryInfo di, string prefix, string suffix, long generation)
{
string searchPattern = EseHelper.MakeLogfileName(prefix, suffix, generation);
FileInfo[] files = di.GetFiles(searchPattern);
return(files.Length != 0);
}
private DateTime GetFileTime(long generationNumber)
{
string fileName = Path.Combine(this.Configuration.DestinationLogPath, EseHelper.MakeLogfileName(this.Configuration.LogFilePrefix, "." + this.Configuration.LogExtension, generationNumber));
FileInfo fileInfo = new FileInfo(fileName);
return(fileInfo.LastWriteTimeUtc);
}
// Token: 0x0600095F RID: 2399 RVA: 0x0002C270 File Offset: 0x0002A470
public static EseLogRecordPosition GetLastLogRecordPosition(string logfileName, string temporaryDirectory, out Exception ex)
{
EseLogRecordPosition result = null;
ex = null;
try
{
EseLogRecord[] logRecords = EseHelper.GetLogRecords(logfileName, temporaryDirectory);
if (logRecords.Length > 0)
{
result = EseHelper.GetLastLogRecordPosition(logRecords);
}
}
catch (EsentErrorException ex2)
{
ex = ex2;
}
catch (IOException ex3)
{
ex = ex3;
}
catch (UnauthorizedAccessException ex4)
{
ex = ex4;
}
return(result);
}
// Token: 0x06000978 RID: 2424 RVA: 0x0002C885 File Offset: 0x0002AA85
private static void InternalTestBaseNameFromLogfileName()
{
EseHelper.InternalTestBaseNameFromLogfileName("e00.log", "e00");
EseHelper.InternalTestBaseNameFromLogfileName("e0912345678.log", "e09");
EseHelper.InternalTestBaseNameFromLogfileName("c:\\Data\\Files\\E07.log", "e07");
EseHelper.InternalTestBaseNameFromLogfileName("z:\\Log Directory\\w060000AFC.log", "w06");
}
public FileIOonSourceException GetE00Generation(out long e00Gen, string e00Filename)
{
Exception ex = null;
FileIOonSourceException result = null;
e00Gen = 0L;
try
{
e00Gen = EseHelper.GetLogfileGeneration(e00Filename);
ExTraceGlobals.MonitoredDatabaseTracer.TraceDebug <long, string>((long)this.GetHashCode(), "E00 Gen is 0x{0:x} for {1}", e00Gen, e00Filename);
}
catch (EsentErrorException ex2)
{
ex = ex2;
}
catch (IOException ex3)
{
ex = ex3;
}
catch (UnauthorizedAccessException ex4)
{
ex = ex4;
}
if (ex != null)
{
ExTraceGlobals.MonitoredDatabaseTracer.TraceError <string, Exception>((long)this.GetHashCode(), "Could not get generation of {0}: {1}", e00Filename, ex);
result = new FileIOonSourceException(Environment.MachineName, e00Filename, ex.Message, ex);
}
return(result);
}
private long GetGenerationFromFileName(string fileName)
{
long result;
EseHelper.GetGenerationNumberFromFilename(fileName, this.m_prefix, out result);
return(result);
}
public long FindLowestGenerationSlow()
{
string filter = string.Empty;
long? num = null;
for (int i = 7; i >= 0; i--)
{
for (int j = 1; j <= 15; j++)
{
filter = this.BuildFilter(i, j);
num = base.EnumerateFiles(filter, null).Min(delegate(string file)
{
long value;
if (string.IsNullOrEmpty(file) || !EseHelper.GetGenerationNumberFromFilename(file, this.m_prefix, out value))
{
return(null);
}
return(new long?(value));
});
if (num != null)
{
return(num.Value);
}
}
}
return(0L);
}
public string FindHighestGenerationLogFile()
{
string filter = string.Empty;
string result = null;
long? num = null;
for (int i = 0; i < 8; i++)
{
for (int j = 15; j > 0; j--)
{
filter = this.BuildFilter(i, j);
num = base.EnumerateFiles(filter, null).Max(delegate(string file)
{
long value;
if (string.IsNullOrEmpty(file) || !EseHelper.GetGenerationNumberFromFilename(file, this.m_prefix, out value))
{
return(null);
}
return(new long?(value));
});
if (num != null)
{
return(EseHelper.MakeLogfileName(this.m_prefix, this.m_suffix, num.Value));
}
}
}
return(result);
}
// Token: 0x0600096E RID: 2414 RVA: 0x0002C4E4 File Offset: 0x0002A6E4
public static string MakeLogFilePath(IReplayConfiguration config, long generation, string directory)
{
string logfileSuffix = "." + config.LogExtension;
string path = EseHelper.MakeLogfileName(config.LogFilePrefix, logfileSuffix, generation);
return(Path.Combine(directory, path));
}
// Token: 0x06000975 RID: 2421 RVA: 0x0002C6EB File Offset: 0x0002A8EB
internal static void InternalTest()
{
EseHelper.InternalTestBaseNameFromLogfileName();
EseHelper.InternalTestNameGeneration();
EseHelper.InternalTestParseLogfileDump();
EseHelper.InternalTestParseLogfileDumpBadData();
EseHelper.InternalTestCreateTempLog();
}
// Token: 0x0600097B RID: 2427 RVA: 0x0002CFA4 File Offset: 0x0002B1A4
private static void InternalTestParseLogfileDumpBadData()
{
ExTraceGlobals.EseutilWrapperTracer.TraceDebug(0L, "EseHelper.InternalTestParseLogfileDumpBadData");
string value = "LHGX, Create time:12/14/2005 15:30:42 Rand:9483281 Computer:, 00004B9E, 01/23/2006 09:09:02, 01/23/2006 09:06:33, 7.3704.8, 0x0" + Environment.NewLine + string.Empty;
string value2 = "LRPI, 00000000EF1FB879, Insert , 005FE92F, THIS IS BAD DATA, 0000036E, 00000001, 0000000008DCDFA0, 0000000008DCDFD0" + Environment.NewLine + string.Empty;
string text = EseHelper.CreateTemporaryFile(Path.GetTempPath());
DiagCore.RetailAssert(File.Exists(text), "Temporary file {0} doesn't exist.", new object[]
{
text
});
using (StreamWriter streamWriter = new StreamWriter(text, false, Encoding.Unicode))
{
streamWriter.Write(value);
}
try
{
EseHelper.ParseLogfileDump(text);
DiagCore.RetailAssert(false, "Should have thrown an EseutilParseErrorException", new object[0]);
}
catch (EseutilParseErrorException)
{
}
DiagCore.RetailAssert(!File.Exists(text), "File {0} should have been deleted.", new object[]
{
text
});
text = EseHelper.CreateTemporaryFile(Path.GetTempPath());
DiagCore.RetailAssert(File.Exists(text), "Temporary file {0} doesn't exist.", new object[]
{
text
});
using (StreamWriter streamWriter2 = new StreamWriter(text, false, Encoding.Unicode))
{
streamWriter2.Write(value2);
}
try
{
EseHelper.ParseLogfileDump(text);
DiagCore.RetailAssert(false, "Should have thrown an EseutilParseErrorException", new object[0]);
}
catch (EseutilParseErrorException)
{
}
DiagCore.RetailAssert(!File.Exists(text), "File {0} should have been deleted.", new object[]
{
text
});
try
{
EseHelper.GetLogRecords(Path.GetRandomFileName(), Path.GetTempPath());
DiagCore.RetailAssert(false, "Should have thrown EsentErrorException.", new object[0]);
}
catch (EsentErrorException)
{
}
}
private static void MoveTempOldFileToBackupDir(IReplayConfiguration config, string tempOldFile)
{
string currentDateString = FileOperations.GetCurrentDateString();
string text = Path.Combine(config.E00LogBackupPath, currentDateString + "E00OutOfDate");
string text2 = EseHelper.MakeLogFilePath(config, 0L, text);
FileOperations.CreateDirectoryIfNeeded(text);
LastLogReplacer.Tracer.TraceDebug <string, string, string>(0L, "MoveTempOldFileToBackupDir(): '{0}': Moving temporary old file '{1}' to backup file '{2}'", config.DisplayName, tempOldFile, text2);
File.Move(tempOldFile, text2);
}
// Token: 0x06000970 RID: 2416 RVA: 0x0002C548 File Offset: 0x0002A748
public static EseLogRecord[] GetLogRecords(string logfile, string temporaryDirectory)
{
EseLogRecord[] result;
using (TemporaryFile temporaryFile = EseHelper.CreateTemporaryFile(temporaryDirectory))
{
EseHelper.DumpLogRecordsToFile(logfile, temporaryFile);
result = EseHelper.ParseLogfileDump(temporaryFile);
}
return(result);
}
// Token: 0x06000977 RID: 2423 RVA: 0x0002C84C File Offset: 0x0002AA4C
private static void InternalTestBaseNameFromLogfileName(string logfileName, string expectedBaseName)
{
string text = EseHelper.BaseNameFromLogfileName(logfileName);
DiagCore.RetailAssert(expectedBaseName == text, "BaseNameFromLogfileName({0}) returned {1}, expected {2}", new object[]
{
logfileName,
text,
expectedBaseName
});
}
// Token: 0x0600096C RID: 2412 RVA: 0x0002C498 File Offset: 0x0002A698
public static string MakeLogfileName(string logfilePrefix, string logfileSuffix, long generation)
{
if (0L == generation)
{
return(EseHelper.MakeLogfileName(logfilePrefix, logfileSuffix));
}
return(logfilePrefix + string.Format(CultureInfo.InvariantCulture, "{0:X8}", new object[]
{
generation
}) + logfileSuffix);
}
// Token: 0x0600095E RID: 2398 RVA: 0x0002C120 File Offset: 0x0002A320
public static bool IsLogfileEqual(string logfile1, string logfile2, string temporaryDirectory, EseLogRecordPosition lastRec1, EseLogRecordPosition lastRec2)
{
EseLogRecord[] logRecords = EseHelper.GetLogRecords(logfile1, temporaryDirectory);
EseLogRecord[] logRecords2 = EseHelper.GetLogRecords(logfile2, temporaryDirectory);
if (lastRec1 != null)
{
EseLogRecordPosition lastLogRecordPosition = EseHelper.GetLastLogRecordPosition(logRecords);
if (lastLogRecordPosition != null)
{
lastRec1.LogPos = lastLogRecordPosition.LogPos;
lastRec1.LogRecordLength = lastLogRecordPosition.LogRecordLength;
lastRec1.LogSectorSize = lastLogRecordPosition.LogSectorSize;
}
}
if (lastRec2 != null)
{
EseLogRecordPosition lastLogRecordPosition2 = EseHelper.GetLastLogRecordPosition(logRecords2);
if (lastLogRecordPosition2 != null)
{
lastRec2.LogPos = lastLogRecordPosition2.LogPos;
lastRec2.LogRecordLength = lastLogRecordPosition2.LogRecordLength;
lastRec2.LogSectorSize = lastLogRecordPosition2.LogSectorSize;
}
}
if (logRecords2.Length != logRecords.Length)
{
ExTraceGlobals.EseutilWrapperTracer.TraceDebug(0L, "IsLogfileEqual({0},{1}) returns false. {0} has {2} records. {1} has {3} records.", new object[]
{
logfile1,
logfile2,
logRecords.Length,
logRecords2.Length
});
return(false);
}
for (int i = 0; i < logRecords.Length; i++)
{
if (logRecords[i].ToString() != logRecords2[i].ToString())
{
ExTraceGlobals.EseutilWrapperTracer.TraceDebug(0L, "IsLogfileEqual({0},{1}) returns false. {0} has {2} records. {1} has {3} records. The differing log records are {4} and {5}. Differing position is {6}.", new object[]
{
logfile1,
logfile2,
logRecords.Length,
logRecords2.Length,
logRecords[i],
logRecords2[i],
i
});
return(false);
}
}
return(true);
}
// Token: 0x06001BBC RID: 7100 RVA: 0x00076FFC File Offset: 0x000751FC
private DateTime GetWriteTimeFromLastCopiedGeneration()
{
long arg = -1L;
string text = null;
DateTime result = ReplayState.ZeroFileTime;
Exception ex = null;
bool flag = false;
try
{
long[] array = new long[]
{
0L,
this.LastLogShipped
};
foreach (long num in array)
{
string text2 = EseHelper.MakeLogFilePath(this.m_configuration, num, this.m_configuration.DestinationLogPath);
arg = num;
text = text2;
FileInfo fileInfo = new FileInfo(text2);
if (fileInfo.Exists)
{
result = fileInfo.LastWriteTimeUtc;
flag = true;
break;
}
}
}
catch (IOException ex2)
{
ex = ex2;
}
catch (SecurityException ex3)
{
ex = ex3;
}
catch (UnauthorizedAccessException ex4)
{
ex = ex4;
}
if (ex != null)
{
AttemptCopyLastLogs.Tracer.TraceError <long, string, Exception>((long)this.GetHashCode(), "GetWriteTimeFromGeneration() for gen {0}, log file '{1}' threw exception: {2}", arg, text, ex);
throw new AcllLastLogTimeErrorException(this.m_configuration.DisplayName, text, ex.Message, ex);
}
if (!flag)
{
throw new AcllLastLogNotFoundException(this.m_configuration.DisplayName, this.LastLogShipped);
}
return(result);
}
public static void ReplaceLastLog(IReplayConfiguration config, long logGen, string oldFilePath, string newFilePath)
{
string targetLogFilePath = EseHelper.MakeLogFilePath(config, logGen, config.DestinationLogPath);
string fileName = Path.GetFileName(targetLogFilePath);
string tempNewFilePath = Path.Combine(config.DestinationLogPath, fileName + ".ReplacementNew");
string tempOldFilePath = oldFilePath + ".ReplacementOld";
string e00LogPath = EseHelper.MakeLogFilePath(config, 0L, config.DestinationLogPath);
Exception ex = LastLogReplacer.HandleExceptions(delegate
{
if (!File.Exists(oldFilePath))
{
DiagCore.AssertOrWatson(false, "ReplaceLastLog(): File '{0}' not found!", new object[]
{
oldFilePath
});
throw new LastLogReplacementFailedFileNotFoundException(config.DisplayName, oldFilePath, e00LogPath);
}
if (!File.Exists(newFilePath))
{
DiagCore.AssertOrWatson(false, "ReplaceLastLog(): File '{0}' not found!", new object[]
{
newFilePath
});
throw new LastLogReplacementFailedFileNotFoundException(config.DisplayName, newFilePath, e00LogPath);
}
if (File.Exists(tempNewFilePath))
{
DiagCore.AssertOrWatson(false, "ReplaceLastLog(): File '{0}' was not expected to be found. Was RollbackLastLogIfNecessary() successfully called?", new object[]
{
tempNewFilePath
});
throw new LastLogReplacementFailedUnexpectedFileFoundException(config.DisplayName, tempNewFilePath, e00LogPath);
}
if (File.Exists(tempOldFilePath))
{
DiagCore.AssertOrWatson(false, "ReplaceLastLog(): File '{0}' was not expected to be found. Was RollbackLastLogIfNecessary() successfully called?", new object[]
{
tempOldFilePath
});
throw new LastLogReplacementFailedUnexpectedFileFoundException(config.DisplayName, tempOldFilePath, e00LogPath);
}
File.Move(newFilePath, tempNewFilePath);
File.Move(oldFilePath, tempOldFilePath);
File.Move(tempNewFilePath, targetLogFilePath);
LastLogReplacer.MoveTempOldFileToBackupDir(config, tempOldFilePath);
});
if (ex != null)
{
throw new LastLogReplacementFailedErrorException(config.DisplayName, e00LogPath, ex.Message, ex);
}
}
// Token: 0x06001E89 RID: 7817 RVA: 0x0008A8F8 File Offset: 0x00088AF8
public bool Start()
{
this.SafetyNetVersionChecker.Start();
this.ConfigurationUpdater.Start();
this.DumpsterRedeliveryManager.Start();
this.SkippedLogsDeleter.Start();
this.SearchServiceMonitor.Start();
EseHelper.GlobalInit();
ExTraceGlobals.PFDTracer.TracePfd <int>((long)this.GetHashCode(), "PFD CRS {0} EseHelper Initialization", 31901);
if (this.HealthThread != null)
{
this.HealthThread.Start();
}
return(true);
}
// Token: 0x06000971 RID: 2417 RVA: 0x0002C598 File Offset: 0x0002A798
internal static void DumpLogRecordsToFile(string logfile, string outputFile)
{
ExTraceGlobals.EseutilWrapperTracer.TraceDebug <string, string>(0L, "Dumping logfile {0} to output file {1}", logfile, outputFile);
string basename = EseHelper.BaseNameFromLogfileName(logfile);
LogVerifier logVerifier = new LogVerifier(basename, outputFile);
try
{
logVerifier.Dump(logfile);
}
finally
{
logVerifier.Term();
}
}
// Token: 0x06000976 RID: 2422 RVA: 0x0002C708 File Offset: 0x0002A908
private static void InternalTestCreateTempLog()
{
string randomFileName = Path.GetRandomFileName();
string text = "e13";
string destFileName = Path.Combine(randomFileName, "e13.log");
string text2 = Path.Combine(randomFileName, "e13tmp.log");
DiagCore.RetailAssert(!File.Exists(text2), "file {0} shouldn't exist", new object[]
{
text2
});
Exception ex;
bool condition = EseHelper.CreateTempLog(text, randomFileName, out ex);
DiagCore.RetailAssert(condition, "CreateTempLog({0},{1}) returned false", new object[]
{
text,
randomFileName
});
DiagCore.RetailAssert(File.Exists(text2), "file {0} should exist", new object[]
{
text2
});
condition = EseHelper.CreateTempLog(text, randomFileName, out ex);
DiagCore.RetailAssert(condition, "CreateTempLog({0},{1}) returned false", new object[]
{
text,
randomFileName
});
DiagCore.RetailAssert(File.Exists(text2), "file {0} should exist", new object[]
{
text2
});
File.Move(text2, destFileName);
condition = EseHelper.CreateTempLog(text, randomFileName, out ex);
DiagCore.RetailAssert(condition, "CreateTempLog({0},{1}) returned false", new object[]
{
text,
randomFileName
});
DiagCore.RetailAssert(!File.Exists(text2), "file {0} shouldn't exist", new object[]
{
text2
});
Directory.Delete(randomFileName, true);
}
public void Initialize(long logGeneration, string logPath, string prefix, string suffix)
{
string text = Path.Combine(logPath, EseHelper.MakeLogfileName(prefix, suffix, logGeneration));
this.Initialized = false;
try
{
JET_LOGINFOMISC logInfo;
UnpublishedApi.JetGetLogFileInfo(text, out logInfo, JET_LogInfo.Misc2);
LocalizedString localizedString;
this.Examine(logInfo, text, out localizedString);
}
catch (EsentErrorException ex)
{
LogContinuityChecker.Tracer.TraceError <string, EsentErrorException>((long)this.GetHashCode(), "LogContinuityChecker failed to init with '{0}': {1}", text, ex);
throw new LogInspectorFailedGeneralException(text, ex.Message, ex);
}
}
private LogVerifier(string basename, bool ignored)
{
bool flag = false;
EseHelper.GlobalInit();
this.m_instanceName = string.Concat(new object[]
{
"Log Verifier ",
basename,
" ",
this.GetHashCode()
});
Api.JetCreateInstance(out this.m_instance, this.m_instanceName);
this.m_basename = basename;
bool jettermNeeded = true;
try
{
InstanceParameters instanceParameters = new InstanceParameters(this.Instance);
instanceParameters.Recovery = false;
instanceParameters.MaxTemporaryTables = 0;
instanceParameters.NoInformationEvent = true;
instanceParameters.EventLoggingLevel = EventLoggingLevels.Min;
instanceParameters.BaseName = basename;
jettermNeeded = false;
Api.JetInit(ref this.m_instance);
jettermNeeded = true;
Api.JetBeginSession(this.Instance, out this.m_sesid, null, null);
this.m_dbutil = new JET_DBUTIL();
this.m_dbutil.sesid = this.Sesid;
this.m_dbutil.op = DBUTIL_OP.DumpLogfile;
this.AssertNotTerminated();
flag = true;
}
finally
{
if (!flag)
{
this.Term(jettermNeeded);
}
}
}
// Token: 0x06000979 RID: 2425 RVA: 0x0002C8C4 File Offset: 0x0002AAC4
private static void InternalTestNameGeneration()
{
ExTraceGlobals.EseutilWrapperTracer.TraceDebug(0L, "EseHelper.InternalTestNameGeneration");
string text = EseHelper.MakeCheckpointFileName("E09");
DiagCore.RetailAssert("E09.chk" == text, "MakeCheckpointFileName returned {0}", new object[]
{
text
});
text = EseHelper.MakeLogfileName("E00", ".jtx", 5670691L);
DiagCore.RetailAssert("E0000568723.jtx" == text, "MakeLogfileName returned {0}", new object[]
{
text
});
text = EseHelper.MakeLogfileName("E01", ".log");
DiagCore.RetailAssert("E01.log" == text, "MakeLogfileName returned {0}", new object[]
{
text
});
}
// Token: 0x06001B12 RID: 6930 RVA: 0x0007430C File Offset: 0x0007250C
public bool Start()
{
bool fStarted;
lock (this)
{
if (!this.m_fStarted)
{
EseHelper.GlobalInit();
this.m_cleaner.Start();
this.m_fStarted = true;
}
else
{
ExTraceGlobals.SeederServerTracer.TraceDebug((long)this.GetHashCode(), "SeedManager is already started.");
}
fStarted = this.m_fStarted;
}
return(fStarted);
}
private static void DeleteTempOldFile(IReplayConfiguration config, string tempOldFile)
{
Exception ex = LastLogReplacer.HandleExceptions(delegate
{
long logfileGeneration = EseHelper.GetLogfileGeneration(tempOldFile);
string text = EseHelper.MakeLogFilePath(config, logfileGeneration, config.DestinationLogPath);
if (!File.Exists(text))
{
string text2 = EseHelper.MakeLogFilePath(config, 0L, config.DestinationLogPath);
if (!File.Exists(text2))
{
DiagCore.AssertOrWatson(false, "DeleteTempOldFile(): tempOldFile '{0}' has generation {1}, but corresponding numbered log '{2}' was not found!", new object[]
{
tempOldFile,
logfileGeneration,
text
});
throw new LastLogReplacementUnexpectedTempFilesException(config.DisplayName, config.DestinationLogPath);
}
text = text2;
}
LastLogReplacer.Tracer.TraceDebug <string, string>(0L, "DeleteTempOldFile(): '{0}': Found previously replaced file to be: {1}", config.DisplayName, text);
bool flag = EseHelper.IsLogfileSubset(text, tempOldFile, config.E00LogBackupPath, null, null);
DiagCore.AssertOrWatson(flag, "LastLogReplacer.RollbackLastLogIfNecessary(): File '{0}' is not a subset of replaced numbered log file '{1}', as expected!", new object[]
{
tempOldFile,
text
});
if (!flag)
{
throw new LastLogReplacementFileNotSubsetException(config.DisplayName, tempOldFile, text);
}
LastLogReplacer.MoveTempOldFileToBackupDir(config, tempOldFile);
});
if (ex != null)
{
throw new LastLogReplacementTempOldFileNotDeletedException(config.DisplayName, tempOldFile, ex.Message, ex);
}
}