private void Run()
{
AutoReseedManager.Tracer.TraceDebug((long)this.GetHashCode(), "AutoReseedManager: Entering Run()...");
this.ResetState();
IMonitoringADConfig config = this.m_adConfigProvider.GetConfig(true);
if (MountPointUtil.IsConfigureMountPointsEnabled())
{
AutoReseedManager.Tracer.TraceDebug((long)this.GetHashCode(), "AutoReseedManager: Skipping running AutoReseedManager because regkey '{0}' is enabled.");
return;
}
if (config.ServerRole == MonitoringServerRole.Standalone)
{
AutoReseedManager.Tracer.TraceDebug((long)this.GetHashCode(), "AutoReseedManager: Skipping running AutoReseedManager because local server is not a member of a DAG.");
return;
}
if (!config.Dag.AutoDagAutoReseedEnabled)
{
AutoReseedManager.Tracer.TraceDebug <string>((long)this.GetHashCode(), "AutoReseedManager: Skipping running AutoReseedManager because the local DAG '{0}' has AutoDagAutoReseedEnabled set to disabled.", config.Dag.Name);
return;
}
if (DiskReclaimerManager.ShouldSkipDueToServerNotConfigured(config.TargetMiniServer))
{
AutoReseedManager.Tracer.TraceDebug <AmServerName>((long)this.GetHashCode(), "AutoReseedManager: Skipping running AutoReseedManager because the local server '{0}' is not yet fully configured in the AD.", config.TargetServerName);
return;
}
this.m_volumeManager.Refresh(config);
IEnumerable <IADDatabase> enumerable = config.DatabaseMap[config.TargetServerName];
foreach (IADDatabase db in enumerable)
{
this.ProcessDatabase(db, enumerable, config);
}
}
// Token: 0x06001D6B RID: 7531 RVA: 0x000854DC File Offset: 0x000836DC
private bool IsFileBinaryEqual(string filename1, string filename2, out Exception ex)
{
bool isEqual = false;
ex = MountPointUtil.HandleIOExceptions(delegate
{
isEqual = IncrementalReseeder.IsFileBinaryEqual(filename1, filename2);
});
return(isEqual);
}
private void UpdateVolumeForNeverMountedActives(IMonitoringADConfig adConfig)
{
IEnumerable <IADDatabase> enumerable = adConfig.DatabaseMap[adConfig.TargetServerName];
IEnumerable <CopyStatusClientCachedEntry> copyStatusesByServer = this.m_statusLookup.GetCopyStatusesByServer(adConfig.TargetServerName, enumerable, CopyStatusClientLookupFlags.None);
Exception ex = null;
List <IADDatabase> neverMountedActives = this.m_volumeManager.GetNeverMountedActives(enumerable, adConfig, copyStatusesByServer);
if (neverMountedActives != null && neverMountedActives.Count > 0)
{
ICollection <string> source = from db in neverMountedActives
select db.Name;
DiskReclaimerManager.Tracer.TraceDebug <int, string>((long)this.GetHashCode(), "DiskReclaimer: UpdateVolumeForNeverMountedActives() Number of never mounted active databases missing volume = {0}. Databases: '{1}'", neverMountedActives.Count, string.Join(",", source.ToArray <string>()));
ReplayCrimsonEvents.DiskReclaimerNeverMountedActives.Log <int, string>(neverMountedActives.Count, string.Join(",", source.ToArray <string>()));
}
foreach (IADDatabase iaddatabase in neverMountedActives)
{
bool flag = false;
DatabaseVolumeInfo instance = DatabaseVolumeInfo.GetInstance(iaddatabase.EdbFilePath.PathName, iaddatabase.LogFolderPath.PathName, iaddatabase.Name, adConfig.Dag.AutoDagVolumesRootFolderPath.PathName, adConfig.Dag.AutoDagDatabasesRootFolderPath.PathName, adConfig.Dag.AutoDagDatabaseCopiesPerVolume);
if (instance.IsValid && MountPointUtil.IsDirectoryAccessibleMountPoint(instance.DatabaseVolumeMountPoint.Path, out ex))
{
flag = true;
}
else
{
ReplayCrimsonEvents.DiskReclaimerNeverMountedActiveMissingVolume.Log <string>(iaddatabase.Name);
if (this.m_volumeManager.FixActiveDatabaseMountPoint(iaddatabase, enumerable, adConfig, out ex, true))
{
flag = true;
this.m_volumeManager.UpdateVolumeInfoCopyState(iaddatabase.Guid, this.m_replicaInstanceManager);
}
else
{
DiskReclaimerManager.Tracer.TraceError <string, string>((long)this.GetHashCode(), "DiskReclaimer: UpdateVolumeForNeverMountedActives() failed to fix up active database: '{0}' mountpoint. Error: {1}", iaddatabase.Name, AmExceptionHelper.GetExceptionMessageOrNoneString(ex));
ReplayCrimsonEvents.DiskReclaimerFixActiveMountPointError.Log <string, string>(iaddatabase.Name, ex.Message);
}
}
if (flag)
{
ex = this.MountDatabaseWrapper(iaddatabase);
if (ex != null)
{
DiskReclaimerManager.Tracer.TraceError <string, string>((long)this.GetHashCode(), "DiskReclaimer: UpdateVolumeForNeverMountedActives() failed to mount active database: '{0}' mountpoint. Error: {1}", iaddatabase.Name, ex.Message);
ReplayCrimsonEvents.DiskReclaimerMountActiveDatabaseError.Log <string, string>(iaddatabase.Name, ex.Message);
}
}
}
ReplayCrimsonEvents.DiskReclaimerFixActiveMountPointCompleted.Log <string>(adConfig.TargetServerName.NetbiosName);
this.m_volumeManager.Refresh(adConfig);
}
private void EnumerateFilesForDirectory(TopNList <DirectorySpaceEnumerator.DirectorySize> topDirsBySize, string dir)
{
MountPointUtil.HandleIOExceptions(delegate
{
DirectoryInfo path = new DirectoryInfo(dir);
using (DirectoryEnumerator directoryEnumerator = new DirectoryEnumerator(path, false, false))
{
ulong num = 0UL;
string text;
NativeMethods.WIN32_FIND_DATA win32_FIND_DATA;
while (directoryEnumerator.GetNextFileExtendedInfo("*", out text, out win32_FIND_DATA))
{
ulong longFileSize = this.GetLongFileSize(win32_FIND_DATA.FileSizeLow, win32_FIND_DATA.FileSizeHigh);
num += longFileSize;
}
this.InsertIfNecessary(topDirsBySize, dir, num);
}
});
}
private IEnumerable <DirectorySpaceEnumerator.DirectorySize> GetTopNDirectories()
{
TopNList <DirectorySpaceEnumerator.DirectorySize> topDirsBySize = new TopNList <DirectorySpaceEnumerator.DirectorySize>(this.m_maxDirectories, Dependencies.Assert);
MountPointUtil.HandleIOExceptions(delegate
{
DirectoryInfo path = new DirectoryInfo(this.m_rootDirectory);
using (DirectoryEnumerator directoryEnumerator = new DirectoryEnumerator(path, true, true))
{
Predicate <NativeMethods.WIN32_FIND_DATA> extendedFilter = (NativeMethods.WIN32_FIND_DATA findData) => (findData.FileAttributes & NativeMethods.FileAttributes.ReparsePoint) == NativeMethods.FileAttributes.None;
foreach (string dir in directoryEnumerator.EnumerateDirectories("*", extendedFilter))
{
this.EnumerateFilesForDirectory(topDirsBySize, dir);
}
this.EnumerateFilesForDirectory(topDirsBySize, this.m_rootDirectory);
}
});
return(topDirsBySize);
}
protected override Exception ExecuteInternal(AutoReseedWorkflowState state)
{
Exception ex = null;
bool flag = false;
IVolumeManager volumeManager = base.Context.VolumeManager;
IADDatabase database = base.Context.Database;
MountedFolderPath databaseMountedFolderPath = VolumeManager.GetDatabaseMountedFolderPath(base.Context.Dag.AutoDagDatabasesRootFolderPath, database.Name);
if (MountPointUtil.IsDirectoryAccessibleMountPoint(databaseMountedFolderPath.Path, out ex))
{
flag = true;
}
else
{
ReplayCrimsonEvents.AutoReseedNeverMountedActiveMissingVolume.Log <string>(database.Name);
if (volumeManager.FixActiveDatabaseMountPoint(database, base.Context.Databases, base.Context.AdConfig, out ex, true))
{
flag = true;
volumeManager.UpdateVolumeInfoCopyState(database.Guid, base.Context.ReplicaInstanceManager);
ReplayCrimsonEvents.AutoReseedNeverMountedActiveAllocatedVolume.Log <string, string>(database.Name, base.Context.TargetCopyStatus.CopyStatus.LogVolumeName);
}
else
{
AutoReseedWorkflow.Tracer.TraceError <string, string>((long)this.GetHashCode(), "DiskReclaimer: UpdateVolumeForNeverMountedActives() failed to fix up active database: '{0}' mountpoint. Error: {1}", database.Name, AmExceptionHelper.GetExceptionMessageOrNoneString(ex));
ReplayCrimsonEvents.AutoReseedFixActiveMountPointError.Log <string, string>(database.Name, AmExceptionHelper.GetExceptionMessageOrNoneString(ex));
}
}
if (!flag)
{
AutoReseedWorkflow.Tracer.TraceError <string, string>((long)this.GetHashCode(), "DiskReclaimer: UpdateVolumeForNeverMountedActives() active database: '{0}' does not have a mountpoint. Skip issuing Store Mount. Error: {1}", database.Name, AmExceptionHelper.GetExceptionMessageOrNoneString(ex));
return(ex);
}
ex = AmRpcClientHelper.AdminMountDatabaseWrapper(database);
if (ex != null)
{
AutoReseedWorkflow.Tracer.TraceError <string, string>((long)this.GetHashCode(), "DiskReclaimer: UpdateVolumeForNeverMountedActives() failed to mount active database: '{0}' mountpoint. Error: {1}", database.Name, ex.Message);
ReplayCrimsonEvents.AutoReseedMountActiveDatabaseError.Log <string, string>(database.Name, ex.Message);
}
return(ex);
}
private void Run()
{
DiskReclaimerManager.Tracer.TraceDebug((long)this.GetHashCode(), "DiskReclaimer: Entering Run()...");
IMonitoringADConfig config = this.m_adConfigProvider.GetConfig(true);
if (config.ServerRole == MonitoringServerRole.Standalone)
{
DiskReclaimerManager.Tracer.TraceDebug((long)this.GetHashCode(), "DiskReclaimer: Skipping running DiskReclaimerManager because local server is not a member of a DAG.");
return;
}
if (!config.Dag.AutoDagDiskReclaimerEnabled)
{
DiskReclaimerManager.Tracer.TraceDebug <string>((long)this.GetHashCode(), "DiskReclaimer: Skipping running DiskReclaimerManager because the local DAG '{0}' has AutoDagDiskReclaimerEnabled set to disabled.", config.Dag.Name);
return;
}
if (DiskReclaimerManager.ShouldSkipDueToServerNotConfigured(config.TargetMiniServer))
{
DiskReclaimerManager.Tracer.TraceDebug <AmServerName>((long)this.GetHashCode(), "DiskReclaimer: Skipping running DiskReclaimerManager because the local server '{0}' is not yet fully configured in the AD.", config.TargetServerName);
return;
}
this.m_volumeManager.Refresh(config);
if (MountPointUtil.IsConfigureMountPointsEnabled())
{
bool flag = false;
DiskReclaimerManager.Tracer.TraceDebug((long)this.GetHashCode(), "DiskReclaimer: Regkey ConfigureMountPointsPostReInstall is set. Starting mountpoint configuration on all Exchange volumes.");
ReplayCrimsonEvents.DiskReclaimerPostInstallConfigStarted.LogPeriodic <string>(Environment.MachineName, DiagCore.DefaultEventSuppressionInterval, "ConfigureMountPointsPostReInstall");
this.ConfigureVolumesPostReInstall(config, out flag);
this.m_volumeManager.Refresh(config);
if (flag)
{
DiskReclaimerManager.Tracer.TraceDebug((long)this.GetHashCode(), "DiskReclaimer: Database copies might be missing in AD. ConfigureMountPointsPostReInstall will not be disabled to allow DiskReclaimer to run again.");
return;
}
this.UpdateVolumeForNeverMountedActives(config);
ReplayCrimsonEvents.DiskReclaimerPostInstallConfigCompleted.LogPeriodic <string>(Environment.MachineName, DiagCore.DefaultEventSuppressionInterval, "ConfigureMountPointsPostReInstall");
DiskReclaimerManager.m_lastVolumeScanTime = DateTime.MinValue;
Exception ex;
if ((ex = MountPointUtil.DisableConfigureMountPoints()) != null)
{
DiskReclaimerManager.Tracer.TraceError <Exception>((long)this.GetHashCode(), "DiskReclaimer: Failed to reset regkey ConfigureMountPointsPostReInstall after configuring mountpoints. Error: {0}", ex);
ReplayCrimsonEvents.DiskReclaimerError.LogPeriodic <Exception>(Environment.MachineName, DiagCore.DefaultEventSuppressionInterval, ex);
}
}
this.m_volumeManager.DetermineMisconfiguredVolumes(config);
if (!this.IsSafeToLookForQuarantinedDisks())
{
DiskReclaimerManager.Tracer.TraceDebug((long)this.GetHashCode(), "DiskReclaimer: Skip scanning for quarantined volumes...");
return;
}
DiskReclaimerManager.m_lastVolumeScanTime = DateTime.UtcNow;
ReplayCrimsonEvents.DiskReclaimerInitiated.Log();
List <ExchangeVolume>[] array = this.m_volumeManager.DetermineVolumeSpareStatuses();
List <ExchangeVolume> list = array[4];
if (list == null || list.Count == 0)
{
DiskReclaimerManager.Tracer.TraceDebug((long)this.GetHashCode(), "Run(): No volumes that need to be reclaimed found. Exiting.");
}
else
{
DiskReclaimerManager.Tracer.TraceDebug <int>((long)this.GetHashCode(), "DiskReclaimer: Found {0} volumes that can potentially be reclaimed.", list.Count);
DatabaseHealthValidationRunner databaseHealthValidationRunner = new DatabaseHealthValidationRunner(config.TargetServerName.NetbiosName);
databaseHealthValidationRunner.Initialize();
List <string> list2 = new List <string>();
foreach (IHealthValidationResultMinimal healthValidationResultMinimal in databaseHealthValidationRunner.RunDatabaseRedundancyChecksForCopyRemoval(true, null, true, true, -1))
{
if (!healthValidationResultMinimal.IsValidationSuccessful)
{
list2.Add(healthValidationResultMinimal.ErrorMessageWithoutFullStatus);
}
}
if (list2.Count == 0)
{
DiskReclaimerManager.Tracer.TraceDebug((long)this.GetHashCode(), "DiskReclaimer: Passed copy removal redundancy check for this server. Trying to reclaim one quarantined volume...");
IEnumerable <IADDatabase> enumerable = config.DatabaseMap[config.TargetServerName];
IEnumerable <CopyStatusClientCachedEntry> copyStatusesByServer = this.m_statusLookup.GetCopyStatusesByServer(config.TargetServerName, enumerable, CopyStatusClientLookupFlags.None);
using (List <ExchangeVolume> .Enumerator enumerator2 = list.GetEnumerator())
{
while (enumerator2.MoveNext())
{
ExchangeVolume exchangeVolume = enumerator2.Current;
ExchangeVolumeDbStatusInfo filesInformationFromVolume = this.m_volumeManager.GetFilesInformationFromVolume(exchangeVolume, enumerable, copyStatusesByServer);
bool flag2;
Exception ex2;
if (this.m_volumeManager.TryReclaimVolume(exchangeVolume, filesInformationFromVolume, out flag2, out ex2))
{
DiskReclaimerManager.Tracer.TraceDebug <MountedFolderPath, MountedFolderPath>((long)this.GetHashCode(), "DiskReclaimer: Successfully reclaimed volume '{0}' mounted at '{1}' as a spare.", exchangeVolume.VolumeName, exchangeVolume.ExchangeVolumeMountPoint);
ReplayCrimsonEvents.DiskReclaimerSucceeded.Log <string, string>(exchangeVolume.VolumeName.Path, exchangeVolume.ExchangeVolumeMountPoint.Path);
this.m_volumeManager.DetermineVolumeSpareStatuses();
break;
}
if (flag2)
{
DiskReclaimerManager.Tracer.TraceError <MountedFolderPath, MountedFolderPath, Exception>((long)this.GetHashCode(), "DiskReclaimer: Failed to reclaim volume '{0}' mounted at '{1}' as a spare. However, formatting the volume apparently succeeded. Error: {2}", exchangeVolume.VolumeName, exchangeVolume.ExchangeVolumeMountPoint, ex2);
ReplayCrimsonEvents.DiskReclaimerSparingFailed.Log <string, string, bool, string>(exchangeVolume.VolumeName.Path, exchangeVolume.ExchangeVolumeMountPoint.Path, flag2, ex2.Message);
this.m_volumeManager.DetermineVolumeSpareStatuses();
break;
}
DiskReclaimerManager.Tracer.TraceError <MountedFolderPath, MountedFolderPath, Exception>((long)this.GetHashCode(), "DiskReclaimer: Failed to format and reclaim volume '{0}' mounted at '{1}' as a spare. Error: {2}", exchangeVolume.VolumeName, exchangeVolume.ExchangeVolumeMountPoint, ex2);
ReplayCrimsonEvents.DiskReclaimerSparingFailed.Log <string, string, bool, string>(exchangeVolume.VolumeName.Path, exchangeVolume.ExchangeVolumeMountPoint.Path, flag2, ex2.Message);
}
goto IL_477;
}
}
string text = string.Join("\n\n", list2);
DiskReclaimerManager.Tracer.TraceError <string>((long)this.GetHashCode(), "DiskReclaimer: Skip sparing. One or more databases on this server failed copy removal redundancy check. Reason: {0}", text);
ReplayCrimsonEvents.DiskReclaimerRedundancyPrereqFailed.LogPeriodic <string>(text.GetHashCode(), DiagCore.DefaultEventSuppressionInterval, text);
}
IL_477:
this.RunBitlockerMaintenance(config);
}
// Token: 0x06001960 RID: 6496 RVA: 0x00069970 File Offset: 0x00067B70
private LocalizedString RunPrereqsForInPlaceReseed(AutoReseedWorkflowState state)
{
this.TraceBeginPrereqs(state);
int autoReseedDbFailedReseedRetryCountMax = RegistryParameters.AutoReseedDbFailedReseedRetryCountMax;
TimeSpan timeSpan = TimeSpan.FromSeconds((double)RegistryParameters.AutoReseedDbFailedSuspendedWorkflowResetIntervalInSecs);
timeSpan = this.GetWorkflowSuppressionInterval(timeSpan);
if (state.ReseedRecoveryActionRetryCount >= RegistryParameters.AutoReseedDbFailedReseedRetryCountMax)
{
state.WriteWorkflowNextExecutionDueTime(timeSpan);
base.TraceError("RunPrereqsForInPlaceReseed(): Failing 'InPlaceReseed' prereqs since ReseedRecoveryActionRetryCount ({0}) exceeds AutoReseedDbFailedReseedRetryCountMax ({1}). Workflow will next run after {2}.", new object[]
{
state.ReseedRecoveryActionRetryCount,
autoReseedDbFailedReseedRetryCountMax,
timeSpan
});
ReplayCrimsonEvents.AutoReseedWorkflowDbReseedRetryExceeded.Log <string, Guid, string, string, int, TimeSpan>(base.Context.Database.Name, base.Context.Database.Guid, base.WorkflowName, base.WorkflowLaunchReason, autoReseedDbFailedReseedRetryCountMax, timeSpan);
return(ReplayStrings.AutoReseedFailedSeedRetryExceeded(autoReseedDbFailedReseedRetryCountMax));
}
if (base.Context.TargetCopyStatus.CopyStatus.InPlaceReseedBlocked)
{
IEnumerable <CopyStatusClientCachedEntry> enumerable = this.FindTargetDbSetFromDatabaseGroup(base.Context);
if (enumerable == null)
{
enumerable = this.FindTargetDbSetFromNeighbors(base.Context);
if (enumerable == null)
{
return(ReplayStrings.AutoReseedFailedToFindVolumeName);
}
}
MountedFolderPath mountedFolderPath;
if (!this.IsVolumeRecentlyAssigned(enumerable, out mountedFolderPath))
{
string messageOrNoneString = AmExceptionHelper.GetMessageOrNoneString(base.Context.TargetCopyStatus.CopyStatus.ErrorMessage);
state.WriteWorkflowNextExecutionDueTime(timeSpan);
state.ReseedRecoveryActionRetryCount = RegistryParameters.AutoReseedDbFailedReseedRetryCountMax;
base.TraceError("RunPrereqsForInPlaceReseed(): Failing 'InPlaceReseed' prereqs since in-place reseed is blocked. DatabaseCopy has ErrorMessage: {0}. Workflow will next run after {1}.", new object[]
{
messageOrNoneString,
timeSpan
});
ReplayCrimsonEvents.AutoReseedWorkflowDbInPlaceReseedBlocked.Log <string, Guid, string, string, string>(base.Context.Database.Name, base.Context.Database.Guid, base.WorkflowName, base.WorkflowLaunchReason, messageOrNoneString);
return(ReplayStrings.AutoReseedFailedInPlaceReseedBlocked(messageOrNoneString));
}
}
string edbFilePath = base.Context.Database.EdbFilePath.PathName;
if (File.Exists(edbFilePath) && !state.IgnoreInPlaceOverwriteDelay)
{
DateTime lastWriteTimeUtc = DateTime.MaxValue;
Exception ex = MountPointUtil.HandleIOExceptions(delegate
{
FileInfo fileInfo = new FileInfo(edbFilePath);
lastWriteTimeUtc = fileInfo.LastWriteTimeUtc;
});
if (ex != null)
{
lastWriteTimeUtc = base.Context.TargetCopyStatus.CopyStatus.LastStatusTransitionTime;
base.TraceError("RunPrereqsForInPlaceReseed(): Failed to read LastWriteTimeUtc of edb file '{0}'. Using LastStatusTransitionTime of '{1}' instead. Exception: {2}", new object[]
{
edbFilePath,
lastWriteTimeUtc,
ex
});
}
TimeSpan timeSpan2 = DateTime.UtcNow.Subtract(lastWriteTimeUtc);
TimeSpan timeSpan3 = TimeSpan.FromSeconds((double)RegistryParameters.AutoReseedDbFailedInPlaceReseedDelayInSecs);
base.TraceDebug("RunPrereqsForInPlaceReseed(): Found EDB file at '{0}'. The copy was last FailedAndSuspended '{1}' duration ago. Configured reseed delay is: '{2}'.", new object[]
{
edbFilePath,
timeSpan2,
timeSpan3
});
if (timeSpan2 <= timeSpan3)
{
TimeSpan workflowSuppressionInterval = this.GetWorkflowSuppressionInterval(timeSpan3);
state.WriteWorkflowNextExecutionDueTime(workflowSuppressionInterval);
base.TraceError("RunPrereqsForInPlaceReseed(): EDB file exists and Reseed is being attempted too soon. Reseed will be blocked until the configured reseed delay period. Workflow will next run after {0}.", new object[]
{
workflowSuppressionInterval
});
ReplayCrimsonEvents.AutoReseedWorkflowInPlaceReseedTooSoon.Log <string, Guid, string, string, string, TimeSpan, TimeSpan, TimeSpan>(base.Context.Database.Name, base.Context.Database.Guid, base.WorkflowName, base.WorkflowLaunchReason, edbFilePath, timeSpan2, timeSpan3, workflowSuppressionInterval);
return(ReplayStrings.AutoReseedInPlaceReseedTooSoon(timeSpan2.ToString(), timeSpan3.ToString()));
}
}
int num;
if (!base.Context.ReseedLimiter.TryStartSeed(out num))
{
base.TraceError("RunPrereqsForInPlaceReseed(): Seed is being skipped for now because maximum number of concurrent seeds has been reached: {0}", new object[]
{
num
});
return(ReplayStrings.AutoReseedTooManyConcurrentSeeds(num));
}
return(LocalizedString.Empty);
}
