// Token: 0x06001B1C RID: 6940 RVA: 0x00074C1C File Offset: 0x00072E1C
private void ThrowExceptionForExistingInstance(RpcSeederArgs seederArgs, SeederInstanceContainer seederInstance)
{
SeederState seedState = seederInstance.SeedState;
ExTraceGlobals.SeederServerTracer.TraceError <string, Guid, SeederState>((long)this.GetHashCode(), "SeedManager: A SeederInstanceContainer already exists for DB '{0}' ({1}) and is in SeederState '{2}'.", seederArgs.DatabaseName, seederArgs.InstanceGuid, seedState);
if (seedState == SeederState.Unknown)
{
throw new SeederInstanceAlreadyAddedException(seederInstance.SeedingSource);
}
if (seedState == SeederState.SeedPrepared)
{
throw new SeederInstanceAlreadyAddedException(seederInstance.SeedingSource);
}
if (seedState == SeederState.SeedInProgress)
{
throw new SeederInstanceAlreadyInProgressException(seederInstance.SeedingSource);
}
if (seedState == SeederState.SeedSuccessful)
{
throw new SeederInstanceAlreadyCompletedException(seederInstance.SeedingSource);
}
if (seedState == SeederState.SeedCancelled)
{
throw new SeederInstanceAlreadyCancelledException(seederInstance.SeedingSource);
}
if (seedState == SeederState.SeedFailed)
{
throw new SeederInstanceAlreadyFailedException(seederInstance.GetSeedStatus(), seederInstance.SeedingSource);
}
}
// Token: 0x06001B18 RID: 6936 RVA: 0x00074838 File Offset: 0x00072A38
public void EndDbSeed(Guid dbGuid)
{
ExTraceGlobals.SeederServerTracer.TraceDebug <Guid>((long)this.GetHashCode(), "SeedManager: EndDbSeed() called for DB ({0}).", dbGuid);
SeederInstanceContainer seederInstanceContainer;
if (!this.m_seederInstances.TryGetInstance(SafeInstanceTable <SeederInstanceContainer> .GetIdentityFromGuid(dbGuid), out seederInstanceContainer))
{
ExTraceGlobals.SeederServerTracer.TraceDebug <Guid>((long)this.GetHashCode(), "SeedManager: Did NOT find instance for DB ({0})!", dbGuid);
throw new SeederInstanceNotFoundException(dbGuid.ToString());
}
SeederState seedState = seederInstanceContainer.SeedState;
ExTraceGlobals.SeederServerTracer.TraceDebug <Guid, SeederState>((long)this.GetHashCode(), "SeedManager: Found instance for DB ({0}) in state '{1}'.", dbGuid, seedState);
if (seedState == SeederState.SeedSuccessful || seedState == SeederState.SeedCancelled || seedState == SeederState.SeedFailed)
{
this.m_seederInstances.RemoveInstance(seederInstanceContainer);
ExTraceGlobals.SeederServerTracer.TraceDebug <Guid>((long)this.GetHashCode(), "SeedManager: Removed seeder instance for DB ({0}) from table.", dbGuid);
ReplayEventLogConstants.Tuple_SeedInstanceCleanupRequestedByAdmin.LogEvent(null, new object[]
{
seederInstanceContainer.Name
});
return;
}
throw new SeederInstanceInvalidStateForEndException(dbGuid.ToString());
}
protected override void TimerCallbackInternal()
{
SeederInstanceContainer[] allInstances = this.m_instances.GetAllInstances();
foreach (SeederInstanceContainer seederInstanceContainer in allInstances)
{
if (base.PrepareToStopCalled)
{
return;
}
SeederState seedState = seederInstanceContainer.SeedState;
if (seedState == SeederState.SeedSuccessful || seedState == SeederState.SeedCancelled || seedState == SeederState.SeedFailed)
{
DateTime completedTimeUtc = seederInstanceContainer.CompletedTimeUtc;
long num = (long)Math.Ceiling(DateTime.UtcNow.Subtract(completedTimeUtc).TotalMilliseconds);
if (num >= (long)SeederInstanceCleaner.maxDurationMilliSecs)
{
this.m_instances.RemoveInstance(seederInstanceContainer);
ExTraceGlobals.SeederServerTracer.TraceDebug <string, SeederState, long>((long)this.GetHashCode(), "SeederInstanceCleaner: Removed stale seed instance '{0}' in state '{1}' of age {2} secs.", seederInstanceContainer.Identity, seedState, num / 1000L);
ReplayEventLogConstants.Tuple_SeedInstanceCleanupStale.LogEvent(null, new object[]
{
seederInstanceContainer.Name,
num / 1000L
});
}
}
}
}
// Token: 0x060019A7 RID: 6567 RVA: 0x0006B478 File Offset: 0x00069678
private ExEventLog.EventTuple GetEventTupleFromState(SeederState origState)
{
switch (origState)
{
case SeederState.Unknown:
case SeederState.SeedPrepared:
return(ReplayEventLogConstants.Tuple_SeedInstancePrepareFailed);
case SeederState.SeedInProgress:
return(ReplayEventLogConstants.Tuple_SeedInstanceInProgressFailed);
case SeederState.SeedCancelled:
return(ReplayEventLogConstants.Tuple_SeedInstanceCancelled);
}
return(ReplayEventLogConstants.Tuple_SeedInstanceAnotherError);
}
// Token: 0x060019A6 RID: 6566 RVA: 0x0006B40C File Offset: 0x0006960C
private Exception GetException(string error, SeederState origState, Exception innerException)
{
ExTraceGlobals.SeederServerTracer.TraceDebug <SeederState>((long)this.GetHashCode(), "DatabaseSeederInstance: SeederState={0}", origState);
switch (origState)
{
case SeederState.Unknown:
case SeederState.SeedPrepared:
return(new SeedPrepareException(error, innerException));
case SeederState.SeedInProgress:
return(new SeedInProgressException(error, innerException));
case SeederState.SeedCancelled:
return(new SeederOperationAbortedException(innerException));
}
return(new SeederOperationFailedException(error, innerException));
}
// Token: 0x0600199D RID: 6557 RVA: 0x0006AFC0 File Offset: 0x000691C0
protected virtual bool UpdateState(SeederState intendedState, out SeederState actualState, out SeederState origState)
{
bool result = false;
lock (this)
{
actualState = (origState = this.SeedState);
if (SeedStateGraph.IsTransitionPossible(actualState, intendedState))
{
actualState = intendedState;
this.m_seederStatus.State = intendedState;
result = true;
ExTraceGlobals.SeederServerTracer.TraceDebug <SeederState, SeederState>((long)this.GetHashCode(), "DatabaseSeederInstance.UpdateState: Updated seeder state from '{0}' to '{1}'", origState, intendedState);
}
else
{
ExTraceGlobals.SeederServerTracer.TraceDebug <SeederState, SeederState>((long)this.GetHashCode(), "DatabaseSeederInstance.UpdateState: Could not update seeder state from '{0}' to '{1}'", origState, intendedState);
}
}
return(result);
}
// Token: 0x060019A4 RID: 6564 RVA: 0x0006B35C File Offset: 0x0006955C
private string GetMessageAndException(Exception ex, SeederState origState, out Exception newException)
{
newException = null;
string text;
if (ex is SeedPrepareException)
{
newException = ex;
text = ((SeedPrepareException)ex).ErrMessage;
}
else if (ex is SeedInProgressException)
{
newException = ex;
text = ((SeedInProgressException)ex).ErrMessage;
}
else if (ex is SeederServerException)
{
newException = ex;
text = ((SeederServerException)ex).ErrorMessage;
}
else if (ex is SeederServerTransientException)
{
newException = ex;
text = ((SeederServerTransientException)ex).ErrorMessage;
}
else if (ex is IHaRpcServerBaseException)
{
text = ((IHaRpcServerBaseException)ex).ErrorMessage;
}
else
{
text = ex.Message;
}
if (newException == null)
{
newException = this.GetException(text, origState);
}
return(text);
}
// Token: 0x06001998 RID: 6552 RVA: 0x0006ADC0 File Offset: 0x00068FC0
protected void LogError(Exception ex)
{
ReplayCrimsonEvents.SeedingErrorOnTarget.Log <Guid, string, string>(this.DatabaseGuid, this.DatabaseName, ex.ToString());
ExTraceGlobals.SeederServerTracer.TraceError <string, Exception>((long)this.GetHashCode(), "LogError: Database ({0}) failed to seed. Reason: {1}", this.ConfigArgs.Name, ex);
bool flag = false;
try
{
Monitor.Enter(this, ref flag);
SeederState seedState = this.SeedState;
Exception exception = this.GetException(this.GetAppropriateErrorMessage(ex), seedState, ex);
throw exception;
}
finally
{
if (flag)
{
Monitor.Exit(this);
goto IL_6C;
}
goto IL_6C;
IL_6C :;
}
}
// Token: 0x060019A5 RID: 6565 RVA: 0x0006B3FE File Offset: 0x000695FE
private Exception GetException(string error, SeederState origState)
{
return(this.GetException(error, origState, null));
}
// Token: 0x060019A2 RID: 6562 RVA: 0x0006B2C4 File Offset: 0x000694C4
private string GetErrorMessageAndExceptionFromErrorExceptionInfo(RpcErrorExceptionInfo errorExceptionInfo, SeederState origState, out Exception newException)
{
string text;
if (errorExceptionInfo.ReconstitutedException != null)
{
text = this.GetMessageAndException(errorExceptionInfo.ReconstitutedException, origState, out newException);
}
else
{
text = errorExceptionInfo.ErrorMessage;
newException = this.GetException(text, origState);
}
return(text);
}
public static bool IsTransitionPossible(SeederState fromState, SeederState toState)
{
return(SeedStateGraph.m_stateGraph[(int)fromState, (int)toState]);
}
// Token: 0x06001B15 RID: 6933 RVA: 0x000744C4 File Offset: 0x000726C4
public void PrepareDbSeedAndBegin(RpcSeederArgs seederArgs)
{
ExTraceGlobals.SeederServerTracer.TraceDebug((long)this.GetHashCode(), "SeedManager: PrepareDbSeedAndBegin() called.");
SeederInstanceContainer seederInstanceContainer;
bool flag = this.m_seederInstances.TryGetInstance(seederArgs.InstanceGuid, out seederInstanceContainer);
if (flag)
{
this.ThrowExceptionForExistingInstance(seederArgs, seederInstanceContainer);
}
ExTraceGlobals.SeederServerTracer.TraceDebug <string, Guid>((long)this.GetHashCode(), "SeedManager: A SeederInstanceContainer does NOT already exist for DB '{0}' ({1}).", seederArgs.DatabaseName, seederArgs.InstanceGuid);
Dependencies.ADConfig.Refresh("SeedManager.PrepareDbSeedAndBegin");
ReplayConfiguration replayConfiguration;
this.CheckDbValidReplicationTarget(seederArgs, out replayConfiguration);
ConfigurationArgs configurationArgs = new ConfigurationArgs(replayConfiguration, this.m_replicaInstanceManager);
seederInstanceContainer = new SeederInstanceContainer(seederArgs, configurationArgs);
try
{
this.m_seederInstances.AddInstance(seederInstanceContainer);
ReplayEventLogConstants.Tuple_SeedInstancePrepareAdded.LogEvent(null, new object[]
{
configurationArgs.Name,
seederArgs.ToString()
});
}
catch (ArgumentException arg)
{
ExTraceGlobals.SeederServerTracer.TraceError <string, ArgumentException>((long)this.GetHashCode(), "SeedManager: SeederInstanceContainer for db '{0}' has already been added. This indicates another PrepareDbSeed() call got to add it just before this one. Ex: {1}", replayConfiguration.Name, arg);
throw new SeederInstanceAlreadyAddedException(seederInstanceContainer.SeedingSource);
}
try
{
seederInstanceContainer.PrepareDbSeed();
ReplayEventLogConstants.Tuple_SeedInstancePrepareSucceeded.LogEvent(null, new object[]
{
configurationArgs.Name
});
}
finally
{
SeederState seedState = seederInstanceContainer.SeedState;
if (seedState != SeederState.SeedPrepared)
{
this.m_seederInstances.RemoveInstance(seederInstanceContainer);
ExTraceGlobals.SeederServerTracer.TraceDebug <string, SeederState>((long)this.GetHashCode(), "SeedManager: SeederInstanceContainer for db '{0}' is being removed from table because PrepareDbSeed() did not pass (state ={1}, expected was SeedPrepared).", replayConfiguration.Name, seedState);
ReplayEventLogConstants.Tuple_SeedInstancePrepareUnknownError.LogEvent(null, new object[]
{
configurationArgs.Name
});
}
}
ExTraceGlobals.SeederServerTracer.TraceDebug <string>((long)this.GetHashCode(), "SeedManager: SeederInstanceContainer for db '{0} is being queued for seeding since PrepareDbSeed() passed.", replayConfiguration.Name);
try
{
seederInstanceContainer.BeginDbSeed();
ReplayEventLogConstants.Tuple_SeedInstanceBeginSucceeded.LogEvent(null, new object[]
{
configurationArgs.Name
});
}
finally
{
SeederState seedState2 = seederInstanceContainer.SeedState;
if (seedState2 != SeederState.SeedInProgress && seedState2 != SeederState.SeedSuccessful)
{
this.m_seederInstances.RemoveInstance(seederInstanceContainer);
ExTraceGlobals.SeederServerTracer.TraceDebug <string, SeederState>((long)this.GetHashCode(), "SeedManager: SeederInstanceContainer for db '{0}' is being removed from table because BeginDbSeed() did not pass (state = {1}).", replayConfiguration.Name, seedState2);
ReplayEventLogConstants.Tuple_SeedInstanceBeginUnknownError.LogEvent(null, new object[]
{
configurationArgs.Name
});
}
}
}
