// Token: 0x0600195D RID: 6493 RVA: 0x00069564 File Offset: 0x00067764
private LocalizedString RunPrereqsForResume(AutoReseedWorkflowState state)
{
LocalizedString result = LocalizedString.Empty;
this.TraceBeginPrereqs(state);
if (base.Context.TargetCopyStatus.CopyStatus.ResumeBlocked)
{
string messageOrNoneString = AmExceptionHelper.GetMessageOrNoneString(base.Context.TargetCopyStatus.CopyStatus.ErrorMessage);
result = ReplayStrings.AutoReseedFailedResumeBlocked(messageOrNoneString);
base.TraceError("RunPrereqsForResume(): The DatabaseCopy is marked as ResumeBlocked, so Resume stage is being skipped. Workflow will try AssignSpare stage next. DatabaseCopy has ErrorMessage: {0}", new object[]
{
messageOrNoneString
});
ReplayCrimsonEvents.AutoReseedWorkflowDbResumeBlocked.Log <string, Guid, string, string, string>(base.Context.Database.Name, base.Context.Database.Guid, base.WorkflowName, base.WorkflowLaunchReason, messageOrNoneString);
state.UpdateReseedRecoveryAction(ReseedState.AssignSpare);
}
else if (state.ReseedRecoveryActionRetryCount >= RegistryParameters.AutoReseedDbFailedResumeRetryCountMax)
{
int autoReseedDbFailedResumeRetryCountMax = RegistryParameters.AutoReseedDbFailedResumeRetryCountMax;
result = ReplayStrings.AutoReseedFailedResumeRetryExceeded(autoReseedDbFailedResumeRetryCountMax);
base.TraceError("RunPrereqsForResume(): Failing 'Resume' prereqs since ReseedRecoveryActionRetryCount ({0}) exceeds AutoReseedDbFailedResumeRetryCountMax ({1}). Workflow will try AssignSpare stage next.", new object[]
{
state.ReseedRecoveryActionRetryCount,
autoReseedDbFailedResumeRetryCountMax
});
ReplayCrimsonEvents.AutoReseedWorkflowDbResumeRetryExceeded.Log <string, Guid, string, string, int>(base.Context.Database.Name, base.Context.Database.Guid, base.WorkflowName, base.WorkflowLaunchReason, autoReseedDbFailedResumeRetryCountMax);
state.UpdateReseedRecoveryAction(ReseedState.AssignSpare);
}
return(result);
}
// Token: 0x0600194F RID: 6479 RVA: 0x0006886C File Offset: 0x00066A6C
protected override LocalizedString RunPrereqs(AutoReseedWorkflowState state)
{
LocalizedString result = base.RunPrereqs(state);
if (!result.IsEmpty)
{
return(result);
}
result = FailedSuspendedCopyAutoReseedWorkflow.hookableCheckExVolumes.Value(base.Context);
if (!result.IsEmpty)
{
return(result);
}
result = FailedSuspendedCopyAutoReseedWorkflow.CheckDatabaseLogPaths(base.Context);
if (!result.IsEmpty)
{
return(result);
}
if (base.Context.TargetCopyStatus.CopyStatus.ActionInitiator == ActionInitiatorType.Administrator)
{
base.TraceError("RunPrereqs(): The DatabaseCopy has been suspended by an Administrator so AutoReseed will not be attempted.", new object[0]);
return(ReplayStrings.AutoReseedFailedAdminSuspended);
}
if (base.Context.TargetCopyStatus.CopyStatus.ReseedBlocked)
{
string messageOrNoneString = AmExceptionHelper.GetMessageOrNoneString(base.Context.TargetCopyStatus.CopyStatus.ErrorMessage);
base.TraceError("RunPrereqs(): The DatabaseCopy is marked as ReseedBlocked so AutoReseed will not be attempted. Database copy ErrorMessage: {0}", new object[]
{
messageOrNoneString
});
return(ReplayStrings.AutoReseedFailedReseedBlocked(messageOrNoneString));
}
this.ResetWorkflowRecoveryActionIfNecessary(state);
if (!state.IsLastReseedRecoveryActionPending())
{
base.TraceDebug("RunPrereqs(): Running the workflow for the first time, so starting with the Resume action. LastReseedRecoveryAction = {0}", new object[]
{
state.LastReseedRecoveryAction
});
state.UpdateReseedRecoveryAction(ReseedState.Resume);
}
if (state.LastReseedRecoveryAction == ReseedState.Resume)
{
result = this.RunPrereqsForResume(state);
}
if (state.LastReseedRecoveryAction == ReseedState.AssignSpare)
{
result = this.RunPrereqsForAssignSpare(state);
}
if (state.LastReseedRecoveryAction == ReseedState.InPlaceReseed)
{
result = this.RunPrereqsForInPlaceReseed(state);
}
return(result);
}
public void CheckReseedBlocked()
{
lock (this.m_instance)
{
if (this.m_replayState.ReseedBlocked)
{
ExTraceGlobals.ReplicaInstanceTracer.TraceError <string>((long)this.GetHashCode(), "CheckReseedBlocked: {0}: ReseedBlocked is set, so throwing.", this.m_displayName);
throw new SeederInstanceReseedBlockedException(this.m_displayName, AmExceptionHelper.GetMessageOrNoneString(this.ErrorMessage));
}
}
}
// 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);
}
// Token: 0x0600195E RID: 6494 RVA: 0x000696C0 File Offset: 0x000678C0
private LocalizedString RunPrereqsForAssignSpare(AutoReseedWorkflowState state)
{
this.TraceBeginPrereqs(state);
if (state.ReseedRecoveryActionRetryCount >= RegistryParameters.AutoReseedDbFailedAssignSpareRetryCountMax)
{
int autoReseedDbFailedAssignSpareRetryCountMax = RegistryParameters.AutoReseedDbFailedAssignSpareRetryCountMax;
base.TraceError("RunPrereqsForAssignSpare(): Failing 'AssignSpare' prereqs since ReseedRecoveryActionRetryCount ({0}) exceeds AutoReseedDbFailedAssignSpareRetryCountMax ({1}). Workflow will try InPlaceReseed stage next.", new object[]
{
state.ReseedRecoveryActionRetryCount,
autoReseedDbFailedAssignSpareRetryCountMax
});
ReplayCrimsonEvents.AutoReseedWorkflowDbSpareRetryExceeded.Log <string, Guid, string, string, int>(base.Context.Database.Name, base.Context.Database.Guid, base.WorkflowName, base.WorkflowLaunchReason, autoReseedDbFailedAssignSpareRetryCountMax);
state.UpdateReseedRecoveryAction(ReseedState.InPlaceReseed);
return(ReplayStrings.AutoReseedFailedSeedRetryExceeded(autoReseedDbFailedAssignSpareRetryCountMax));
}
state.UpdateReseedRecoveryAction(ReseedState.AssignSpare);
if (string.IsNullOrEmpty(base.Context.TargetCopyStatus.CopyStatus.DatabaseVolumeName) || string.IsNullOrEmpty(base.Context.TargetCopyStatus.CopyStatus.LogVolumeName))
{
return(ReplayStrings.AutoReseedFailedToFindTargetVolumeName(AmExceptionHelper.GetMessageOrNoneString(base.Context.TargetCopyStatus.CopyStatus.VolumeInfoLastError)));
}
MountedFolderPath mountedFolderPath = new MountedFolderPath(base.Context.TargetCopyStatus.CopyStatus.LogVolumeName);
MountedFolderPath other = new MountedFolderPath(base.Context.TargetCopyStatus.CopyStatus.DatabaseVolumeName);
if (!mountedFolderPath.Equals(other))
{
return(ReplayStrings.AutoReseedLogAndDbNotOnSameVolume);
}
IEnumerable <CopyStatusClientCachedEntry> enumerable = this.FindTargetDbSetFromDatabaseGroup(base.Context);
if (enumerable == null)
{
enumerable = this.FindTargetDbSetFromNeighbors(base.Context);
if (enumerable == null)
{
return(ReplayStrings.AutoReseedFailedToFindVolumeName);
}
}
MountedFolderPath mountedFolderPath2;
if (this.IsVolumeRecentlyAssigned(enumerable, out mountedFolderPath2))
{
ReplayCrimsonEvents.AutoReseedWorkflowDbSpareRecentlyAssigned.Log <string, Guid, string, string>(base.Context.Database.Name, base.Context.Database.Guid, base.WorkflowName, base.WorkflowLaunchReason);
state.AssignedVolumeName = mountedFolderPath2.Path;
state.UpdateReseedRecoveryAction(ReseedState.InPlaceReseed);
}
else if (this.DoesMountPointNeedToBeFixed(enumerable, out mountedFolderPath2))
{
base.TraceDebug("Database copy is missing a mount point, and it will be fixed up to point to volume '{0}'", new object[]
{
mountedFolderPath2
});
this.m_volumeForMissingMountPoint = mountedFolderPath2;
}
else
{
string databaseNames = FailedSuspendedCopyAutoReseedWorkflow.GetDatabaseNames(enumerable);
if (!enumerable.All((CopyStatusClientCachedEntry status) => !status.IsActive))
{
return(ReplayStrings.AutoReseedNotAllCopiesPassive(databaseNames));
}
if (!enumerable.All((CopyStatusClientCachedEntry status) => status.Result == CopyStatusRpcResult.Success && status.CopyStatus.CopyStatus == CopyStatusEnum.FailedAndSuspended))
{
return(ReplayStrings.AutoReseedNotAllCopiesOnVolumeFailedSuspended(databaseNames));
}
}
this.m_targetDbSet = enumerable;
return(LocalizedString.Empty);
}
