// Token: 0x06000C41 RID: 3137 RVA: 0x00036478 File Offset: 0x00034678
public static bool IsServerRcrSource(IADDatabase db, IADServer server, out DatabaseLocationInfo activeLocation)
{
ActiveManager noncachingActiveManagerInstance = ActiveManager.GetNoncachingActiveManagerInstance();
activeLocation = noncachingActiveManagerInstance.GetServerForDatabase(db.Guid, GetServerForDatabaseFlags.BasicQuery);
return(Cluster.StringIEquals(activeLocation.ServerFqdn, server.Fqdn));
}
internal bool IsOkayForAction(IADDatabase db, AmServerName nodeName, AmDbActionCode actionCode, int coolingDuration)
{
bool result = true;
if (actionCode == null)
{
return(true);
}
if (!actionCode.IsAutomaticFailureItem)
{
return(true);
}
if (db.ReplicationType == ReplicationType.None)
{
return(true);
}
lock (this.m_locker)
{
Dictionary <AmServerName, AmDbAttemptInfo> dictionary = null;
if (this.m_dbMap.TryGetValue(db.Guid, out dictionary))
{
AmDbAttemptInfo amDbAttemptInfo = null;
if (dictionary.TryGetValue(nodeName, out amDbAttemptInfo))
{
DateTime lastAttemptTime = amDbAttemptInfo.LastAttemptTime;
if ((DateTime)ExDateTime.Now < lastAttemptTime.AddSeconds((double)coolingDuration))
{
result = false;
}
}
}
}
return(result);
}
public AmActiveThirdPartyMove(IADDatabase db, string activeNodeName, bool mountDesired)
{
this.m_db = db;
this.m_currentActiveNodeName = activeNodeName;
this.m_mountDesired = mountDesired;
this.Response = NotificationResponse.Incomplete;
}
// Token: 0x06000C4A RID: 3146 RVA: 0x000367DC File Offset: 0x000349DC
public bool ConfigurationPathConflict(IADDatabase[] databases, out string field)
{
field = string.Empty;
if (databases != null)
{
int i = 0;
while (i < databases.Length)
{
IADDatabase iaddatabase = databases[i];
bool result;
if (Cluster.StringIEquals(this.DestinationLogPath, iaddatabase.LogFolderPath.PathName))
{
field = "DestinationLogPath:" + this.DestinationLogPath;
result = true;
}
else if (Cluster.StringIEquals(this.DestinationEdbPath, iaddatabase.EdbFilePath.PathName))
{
field = "DestinationEdbPath:" + this.DestinationEdbPath;
result = true;
}
else
{
if (!Cluster.StringIEquals(this.DestinationSystemPath, iaddatabase.SystemFolderPath.PathName))
{
i++;
continue;
}
field = "DestinationSystemPath:" + this.DestinationSystemPath;
result = true;
}
return(result);
}
}
return(false);
}
// Token: 0x0600240B RID: 9227 RVA: 0x000A8368 File Offset: 0x000A6568
public void ImmediateDismountMailboxDatabase(Guid databaseId)
{
ExTraceGlobals.ThirdPartyManagerTracer.TraceDebug(0L, "ImmediateDismountMailboxDatabase called");
this.CheckForPam("ImmediateDismountMailboxDatabase");
Exception ex = AmHelper.HandleKnownExceptions(delegate(object param0, EventArgs param1)
{
this.CheckForPam("ImmediateDismountMailboxDatabase");
IADDatabase db = this.LookupDatabase(databaseId);
AmDbActionCode actionCode = new AmDbActionCode(AmDbActionInitiator.Admin, AmDbActionReason.FailureItem, AmDbActionCategory.Dismount);
AmConfig config = AmSystemManager.Instance.Config;
new AmDbPamAction(config, db, actionCode, this.GenerateUniqueDbActionId())
{
LockTimeout = new TimeSpan?(this.m_openTimeout)
}.Dismount(UnmountFlags.SkipCacheFlush);
});
if (ex == null)
{
return;
}
if (ex is ThirdPartyReplicationException)
{
throw ex;
}
throw new ImmediateDismountMailboxDatabaseException(databaseId, ex.Message);
}
// Token: 0x0600241E RID: 9246 RVA: 0x000A8F28 File Offset: 0x000A7128
private void CheckServerForCopy(IADDatabase db, string serverName)
{
AmServerName amServerName = new AmServerName(serverName);
IADDatabaseCopy dbCopy = null;
Exception ex = this.DoADAction(delegate(object param0, EventArgs param1)
{
foreach (IADDatabaseCopy iaddatabaseCopy in db.DatabaseCopies)
{
if (MachineName.Comparer.Equals(iaddatabaseCopy.HostServerName, amServerName.NetbiosName))
{
dbCopy = iaddatabaseCopy;
return;
}
}
});
if (dbCopy != null)
{
return;
}
ExTraceGlobals.ThirdPartyManagerTracer.TraceDebug(0L, "CheckServerForCopy:no copy of {0} guid={1} on {2}. Ex={3}", new object[]
{
db.Name,
db.Guid,
serverName,
ex
});
if (ex == null)
{
throw new NoCopyOnServerException(db.Guid, db.Name, serverName);
}
throw ex;
}
// Token: 0x060011CB RID: 4555 RVA: 0x0004A2BC File Offset: 0x000484BC
public void UpdateAvailabilityRedundancyStates(IMonitoringADConfig adConfig)
{
base.WriterLockedOperation(delegate
{
foreach (DbHealthInfo dbHealthInfo in this.m_dbServerInfos.Values)
{
dbHealthInfo.UpdateAvailabilityRedundancyStates();
}
foreach (ServerHealthInfo serverHealthInfo in this.m_serverInfos.Values)
{
AmServerName serverName = serverHealthInfo.ServerName;
IEnumerable <IADDatabase> dbs;
if (!adConfig.DatabaseMap.TryGetValue(serverName, out dbs))
{
dbs = new IADDatabase[0];
}
bool conditionMet = this.IsAnyDbMatchingCriteria(serverHealthInfo, dbs, (DbHealthInfo dbhi, DbCopyHealthInfo serverCopy) => dbhi.AvailabilityCount <= 1 && serverCopy.IsAvailable());
this.ReportTransition(serverHealthInfo.CriticalForMaintainingAvailability, conditionMet);
bool conditionMet2 = this.IsAnyDbMatchingCriteria(serverHealthInfo, dbs, (DbHealthInfo dbhi, DbCopyHealthInfo serverCopy) => dbhi.RedundancyCount <= 2 && serverCopy.IsRedundant());
this.ReportTransition(serverHealthInfo.CriticalForMaintainingRedundancy, conditionMet2);
bool conditionMet3 = this.IsAnyDbMatchingCriteria(serverHealthInfo, dbs, (DbHealthInfo dbhi, DbCopyHealthInfo serverCopy) => dbhi.AvailabilityCount <= 1 && !serverCopy.IsAvailable());
this.ReportTransition(serverHealthInfo.CriticalForRestoringAvailability, conditionMet3);
bool conditionMet4 = this.IsAnyDbMatchingCriteria(serverHealthInfo, dbs, (DbHealthInfo dbhi, DbCopyHealthInfo serverCopy) => dbhi.RedundancyCount <= 2 && !serverCopy.IsRedundant());
this.ReportTransition(serverHealthInfo.CriticalForRestoringRedundancy, conditionMet4);
int num = this.CountOfDbsMatchingCriteria(serverHealthInfo, dbs, (DbHealthInfo dbhi, DbCopyHealthInfo serverCopy) => dbhi.AvailabilityCount == 2 && !serverCopy.IsAvailable());
this.ReportTransition(serverHealthInfo.HighForRestoringAvailability, num > adConfig.Dag.AutoDagDatabaseCopiesPerVolume);
DbCopyHealthInfoInternalTable.Tracer.TraceDebug <AmServerName, int>((long)this.GetHashCode(), "UpdateAvailabilityRedundancyStates(): For server '{0}', found {1} copies for HighForRestoringAvailability state.", serverName, num);
int num2 = this.CountOfDbsMatchingCriteria(serverHealthInfo, dbs, (DbHealthInfo dbhi, DbCopyHealthInfo serverCopy) => dbhi.RedundancyCount == 3 && !serverCopy.IsRedundant());
this.ReportTransition(serverHealthInfo.HighForRestoringRedundancy, num2 > adConfig.Dag.AutoDagDatabaseCopiesPerVolume);
DbCopyHealthInfoInternalTable.Tracer.TraceDebug <AmServerName, int>((long)this.GetHashCode(), "UpdateAvailabilityRedundancyStates(): For server '{0}', found {1} copies for HighForRestoringRedundancy state.", serverName, num2);
}
});
}
// Token: 0x060011D8 RID: 4568 RVA: 0x0004A898 File Offset: 0x00048A98
private bool DatabaseMatchPredicateWrapper(IADDatabase db, AmServerName serverName, Func <DbHealthInfo, DbCopyHealthInfo, bool> matchPredicate)
{
DbHealthInfo dbHealthInfo = this.m_dbServerInfos[db.Guid];
DbCopyHealthInfo dbCopy = dbHealthInfo.GetDbCopy(serverName);
return(!dbHealthInfo.SkippedFromMonitoring.IsSuccess && matchPredicate(dbHealthInfo, dbCopy));
}
// Token: 0x06000061 RID: 97 RVA: 0x00003424 File Offset: 0x00001624
protected bool AllCopiesAreDisfavored(IADDatabase db)
{
IMonitoringADConfig config = Dependencies.MonitoringADConfigProvider.GetConfig(true);
bool flag = true;
IADDatabaseCopy[] databaseCopies = db.DatabaseCopies;
foreach (IADDatabaseCopy iaddatabaseCopy in databaseCopies)
{
AmServerName serverName = new AmServerName(iaddatabaseCopy.HostServerName);
IADServer iadserver = config.LookupMiniServerByName(serverName);
if (!iadserver.DatabaseCopyActivationDisabledAndMoveNow)
{
flag = false;
break;
}
}
if (flag)
{
AmTrace.Warning("db ({0}) is ActivationDisfavored but no favored server exists. Move is skipped", new object[]
{
db.Name
});
ReplayCrimsonEvents.AllServersMarkedDisfavored.LogPeriodic <Guid, string>(db.Name, DiagCore.DefaultEventSuppressionInterval, db.Guid, db.Name);
}
return(flag);
}
// Token: 0x0600008D RID: 141 RVA: 0x00004904 File Offset: 0x00002B04
private bool IsActiveOnServer(IADDatabase db, AmServerName movingFromServer, out LocalizedString skipReason)
{
bool result = false;
AmDbStateInfo amDbStateInfo = this.m_amConfig.DbState.Read(db.Guid);
if (amDbStateInfo.IsEntryExist)
{
if (AmServerName.IsEqual(movingFromServer, amDbStateInfo.ActiveServer))
{
result = true;
skipReason = LocalizedString.Empty;
}
else
{
AmTrace.Info("IsActiveOnServer: Excluding database {0} from moving since it is not active on {1} (active={2})", new object[]
{
db.Name,
movingFromServer,
amDbStateInfo.ActiveServer
});
skipReason = ReplayStrings.DbMoveSkippedBecauseNotActive(db.Name, movingFromServer.NetbiosName, amDbStateInfo.ActiveServer.NetbiosName);
}
}
else
{
AmTrace.Error("IsActiveOnServer: Failed to find db state info from clusdb (db={0})", new object[]
{
db.Name
});
skipReason = ReplayStrings.DbMoveSkippedBecauseNotFoundInClusDb(db.Name);
}
return(result);
}
// Token: 0x060000B4 RID: 180 RVA: 0x00005508 File Offset: 0x00003708
private HashSet <Guid> GetDatabasesByServer(AmServerName serverName)
{
HashSet <Guid> hashSet = new HashSet <Guid>();
IADConfig adconfig = Dependencies.ADConfig;
IADServer server = adconfig.GetServer(serverName);
if (server != null)
{
IEnumerable <IADDatabase> databasesOnServer = adconfig.GetDatabasesOnServer(serverName);
if (databasesOnServer == null)
{
return(hashSet);
}
using (IEnumerator <IADDatabase> enumerator = databasesOnServer.GetEnumerator())
{
while (enumerator.MoveNext())
{
IADDatabase iaddatabase = enumerator.Current;
hashSet.Add(iaddatabase.Guid);
}
return(hashSet);
}
}
ExTraceGlobals.ClusterTracer.TraceError <AmServerName>((long)this.GetHashCode(), "MiniSever object is null when querying for server '{0}'", serverName);
return(hashSet);
}
internal AmDbOperation(IADDatabase db)
{
this.Database = db;
this.CreationTime = ExDateTime.Now;
this.Counter = (long)Interlocked.Increment(ref AmDbOperation.sm_operationCounter);
this.UniqueId = AmDbOperation.GenerateUniqueId(this.Database.Guid, this.CreationTime, this.Counter);
}
internal void ReportStatus(IADDatabase db, AmDbActionStatus status)
{
lock (this.m_statusInfo)
{
this.m_statusInfo[status] = ExDateTime.Now;
}
if (AmDbOperation.IsCompletionStatus(status) || status == this.CustomStatus)
{
this.IsComplete = true;
}
if (this.CompletionCallback != null && this.IsComplete && !this.m_isCompletionCalled)
{
this.m_isCompletionCalled = true;
this.CompletionCallback(db);
}
if (status == AmDbActionStatus.UpdateMasterServerInitiated)
{
ExTraceGlobals.FaultInjectionTracer.TraceTest(2309369149U);
return;
}
if (status == AmDbActionStatus.StoreMountInitiated)
{
ExTraceGlobals.FaultInjectionTracer.TraceTest(3383110973U);
}
}
public static IADDatabase[] GetAllDatabases(IADToplogyConfigurationSession adSession, IFindAdObject <IADDatabase> databaseLookup, MiniServer miniServer, out Exception exception)
{
IADDatabaseCopy[] copies = null;
QueryFilter serverFilter = new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Name, miniServer.Name);
exception = ADUtils.RunADOperation(delegate()
{
copies = adSession.Find <IADDatabaseCopy>(null, QueryScope.SubTree, serverFilter, null, 0);
}, 2);
if (exception != null)
{
return(null);
}
List <IADDatabase> list = new List <IADDatabase>(20);
foreach (IADDatabaseCopy iaddatabaseCopy in copies)
{
ADObjectId parent = iaddatabaseCopy.Id.Parent;
IADDatabase iaddatabase = databaseLookup.ReadAdObjectByObjectIdEx(parent, out exception);
if (exception != null)
{
return(null);
}
if (iaddatabase != null)
{
list.Add(iaddatabase);
}
}
return((list.Count > 0) ? list.ToArray() : null);
}
// Token: 0x06001957 RID: 6487 RVA: 0x00068E38 File Offset: 0x00067038
private IEnumerable <CopyStatusClientCachedEntry> FindTargetDbSetFromDatabaseGroup(AutoReseedContext context)
{
IADDatabase database = context.Database;
IMonitoringADConfig adConfig = context.AdConfig;
string targetGroup = database.DatabaseGroup;
if (string.IsNullOrWhiteSpace(targetGroup))
{
AutoReseedWorkflow.Tracer.TraceError <string>((long)this.GetHashCode(), "FindTargetDbSetFromDatabaseGroup: DatabaseGroup property for db '{0}' is not set. Returning 'null'.", database.Name);
return(null);
}
IEnumerable <IADDatabase> enumerable = adConfig.DatabaseMap[adConfig.TargetServerName];
if (enumerable == null)
{
AutoReseedWorkflow.Tracer.TraceError <AmServerName>((long)this.GetHashCode(), "FindTargetDbSetFromDatabaseGroup: Server '{0}' had no databases. Returning 'null'.", adConfig.TargetServerName);
return(null);
}
IEnumerable <IADDatabase> source = from db in enumerable
where StringUtil.IsEqualIgnoreCase(db.DatabaseGroup, targetGroup)
select db;
int num = source.Count <IADDatabase>();
if (num != context.Dag.AutoDagDatabaseCopiesPerVolume)
{
AutoReseedWorkflow.Tracer.TraceError <int, string, int>((long)this.GetHashCode(), "FindTargetDbSetFromDatabaseGroup: There are only '{0}' db copies in the group for database '{1}'. Expected number is: {2}. Returning 'null'.", num, database.Name, context.Dag.AutoDagDatabaseCopiesPerVolume);
return(null);
}
Dictionary <Guid, IADDatabase> dbGroupMap = source.ToDictionary((IADDatabase db) => db.Guid);
IEnumerable <CopyStatusClientCachedEntry> source2 = from status in context.CopyStatusesForTargetServer
where dbGroupMap.ContainsKey(status.DbGuid)
select status;
return(source2.ToArray <CopyStatusClientCachedEntry>());
}
// Token: 0x0600029F RID: 671 RVA: 0x0000F7B4 File Offset: 0x0000D9B4
internal AmDbMountOperation(IADDatabase db, AmDbActionCode actionCode) : base(db)
{
this.ActionCode = actionCode;
this.StoreMountFlags = MountFlags.None;
this.AmMountFlags = AmMountFlags.None;
this.MountDialOverride = DatabaseMountDialOverride.None;
}
public static ReplayConfiguration GetLocalReplayConfiguration(Guid dbGuid, IADConfig adConfig, ActiveManager activeManager, out Exception ex)
{
ex = null;
if (activeManager == null)
{
activeManager = ActiveManager.GetNoncachingActiveManagerInstance();
}
IADServer localServer = adConfig.GetLocalServer();
if (localServer == null)
{
ex = new FailedToFindServerException("localmachine");
ExTraceGlobals.ReplayManagerTracer.TraceError <Guid, Exception>(0L, "GetReplayConfiguration ({0}): didn't find any server object for the local machine: {1}", dbGuid, ex);
return(null);
}
IADDatabase database = adConfig.GetDatabase(dbGuid);
if (database == null)
{
ex = new FailedToFindDatabaseException(dbGuid.ToString());
ExTraceGlobals.ReplayManagerTracer.TraceError <Guid>(0L, "GetReplayConfiguration ({0}): Didn't find any mailbox database object from AD.", dbGuid);
return(null);
}
bool flag;
ReplayConfiguration replayConfiguration = ReplayConfiguration.GetReplayConfiguration(adConfig.GetLocalDag(), database, localServer, activeManager, out flag, out ex);
if (ex != null)
{
ExTraceGlobals.ReplayManagerTracer.TraceError <Guid, Exception>(0L, "GetReplayConfiguration ({0}): Error occurred constructing the ReplayConfiguration. Error: {1}", dbGuid, ex);
return(null);
}
return(replayConfiguration);
}
internal AmDbRemountOperation(IADDatabase db, AmDbActionCode actionCode) : base(db)
{
this.ActionCode = actionCode;
this.Flags = MountFlags.None;
this.MountDialOverride = DatabaseMountDialOverride.None;
this.FromServer = null;
}
private List <AmServerName> DetermineServersToContact()
{
Guid guid = this.Database.Guid;
IADDatabase db = this.Database;
IADDatabaseCopy[] databaseCopies = AmBestCopySelectionHelper.GetDatabaseCopies(guid, ref db);
if (db != null)
{
this.Database = db;
}
AmConfig amConfig = AmSystemManager.Instance.Config;
if (amConfig.IsUnknown)
{
AmTrace.Error("AmMultiNodeRpcNotifier: DB {0}: Invalid AM configuration", new object[]
{
db.Name
});
throw new AmInvalidConfiguration(amConfig.LastError ?? string.Empty);
}
IAmBcsErrorLogger errorLogger = new AmBcsSingleCopyFailureLogger();
AmBcsServerChecks checksToRun = AmBcsServerChecks.ClusterNodeUp;
if (this.ActionCode.IsAutomaticOperation)
{
checksToRun |= AmBcsServerChecks.DebugOptionDisabled;
}
IEnumerable <AmServerName> source = from dbCopy in databaseCopies
where this.ValidateServer(new AmServerName(dbCopy.HostServerName), db, amConfig, checksToRun, errorLogger)
select new AmServerName(dbCopy.HostServerName);
return(source.ToList <AmServerName>());
}
// Token: 0x060001A7 RID: 423 RVA: 0x0000A4FC File Offset: 0x000086FC
internal void DismountDatabase(Guid mdbGuid, UnmountFlags flags, AmDbActionCode actionCode)
{
AmTrace.Debug("Task: DismountDatabase({0},{1},{2}) called", new object[]
{
mdbGuid,
flags,
actionCode
});
ActiveManagerCore.ValidatePamOrStandalone("DismountDatabase");
IADDatabase iaddatabase = this.AdLookup.DatabaseLookup.FindAdObjectByGuidEx(mdbGuid, AdObjectLookupFlags.ReadThrough);
if (iaddatabase == null)
{
throw new AmDatabaseNotFoundException(mdbGuid);
}
AmDbDismountOperation amDbDismountOperation = new AmDbDismountOperation(iaddatabase, actionCode);
amDbDismountOperation.Flags = flags;
amDbDismountOperation.Enqueue();
AmDbCompletionReason amDbCompletionReason = amDbDismountOperation.Wait();
AmTrace.Debug("DismountDatabase({0}) completed (reason={1})", new object[]
{
mdbGuid,
amDbCompletionReason
});
}
// Token: 0x060001AF RID: 431 RVA: 0x0000AA50 File Offset: 0x00008C50
internal void RemountDatabase(Guid mdbGuid, MountFlags mountFlags, DatabaseMountDialOverride mountDialOverride, AmServerName fromServer, AmDbActionCode actionCode)
{
AmTrace.Debug("RemountDatabase ({0},{1},{2},{3},{4}) called", new object[]
{
mdbGuid,
mountFlags,
mountDialOverride,
fromServer,
actionCode
});
ActiveManagerCore.ValidatePamOrStandalone("RemountDatabase");
IADDatabase iaddatabase = this.AdLookup.DatabaseLookup.FindAdObjectByGuidEx(mdbGuid, AdObjectLookupFlags.ReadThrough);
if (iaddatabase == null)
{
throw new AmDatabaseNotFoundException(mdbGuid);
}
AmDbRemountOperation amDbRemountOperation = new AmDbRemountOperation(iaddatabase, actionCode);
amDbRemountOperation.Flags = mountFlags;
amDbRemountOperation.MountDialOverride = mountDialOverride;
amDbRemountOperation.FromServer = fromServer;
amDbRemountOperation.Enqueue();
AmDbCompletionReason amDbCompletionReason = amDbRemountOperation.Wait();
AmTrace.Debug("RemountDatabase({0}) completed (reason={1})", new object[]
{
mdbGuid,
amDbCompletionReason
});
}
internal static void WaitUntilDatabaseIsNotMounted(IADDatabase database, int seconds)
{
bool flag = true;
DatabaseTasks.Trace("Waiting for database {0} to reach dismounted/dismounting state for {1} seconds", new object[]
{
database.Name,
seconds
});
for (int i = 0; i < seconds; i++)
{
if (!AmStoreHelper.IsMounted(null, database.Guid))
{
flag = false;
break;
}
Thread.Sleep(1000);
}
if (flag)
{
DatabaseTasks.Trace("Database is still mounted {0} after {1} seconds", new object[]
{
database.Name,
seconds
});
}
}
internal static Exception ResumeLocalDatabaseCopy(IADDatabase database)
{
string localMachineFqdn = DatabaseTasks.LocalMachineFqdn;
Exception ex = null;
try
{
DatabaseCopyActionFlags flags = DatabaseCopyActionFlags.Replication | DatabaseCopyActionFlags.Activation;
Dependencies.ReplayRpcClientWrapper.RequestResume2(localMachineFqdn, database.Guid, (uint)flags);
}
catch (TaskServerException ex2)
{
ex = ex2;
}
catch (TaskServerTransientException ex3)
{
ex = ex3;
}
if (ex != null)
{
DatabaseTasks.Trace("ResumeLocalDatabaseCopy(): Failed with exception: {0}", new object[]
{
ex
});
return(ex);
}
return(null);
}
internal static void SyncDatabaseOwningServerAndLegacyDn(IADDatabase db, AmDbActionCode actionCode)
{
AmConfig config = AmSystemManager.Instance.Config;
AmDbStateInfo amDbStateInfo = config.DbState.Read(db.Guid);
AmServerName amServerName = new AmServerName(db.Server.Name);
AmServerName amServerName2;
if (amDbStateInfo.IsActiveServerValid)
{
amServerName2 = amDbStateInfo.ActiveServer;
}
else
{
amServerName2 = amServerName;
}
AmTrace.Debug("Synchronizing AD properties of database {0} (initialOwningServer:{1}, newActiveServer:{2})", new object[]
{
db.Name,
amServerName,
amServerName2
});
bool flag = SharedDependencies.WritableADHelper.SetDatabaseLegacyDnAndOwningServer(db.Guid, amDbStateInfo.LastMountedServer, amServerName2, false);
if (flag)
{
ReplayCrimsonEvents.DatabaseAdPropertiesSynchronized.Log <string, Guid, AmServerName, AmServerName>(db.Name, db.Guid, amServerName, amServerName2);
return;
}
AmTrace.Debug("Ignored ad sync request database {0}", new object[]
{
db.Name
});
}
internal static void Remount(IADDatabase database, string from)
{
Exception ex = null;
DatabaseTasks.Trace("Database '{0}' is attempting to remount on '{1}'", new object[]
{
database.Name,
from
});
try
{
DatabaseTasks.WaitUntilDatabaseIsNotMounted(database, 5);
AmRpcClientHelper.RemountDatabase(database, 0, -1, from);
}
catch (AmServerException ex2)
{
DatabaseTasks.Trace("RemountDatabase() failed with {0}", new object[]
{
ex2
});
ex = ex2;
}
catch (AmServerTransientException ex3)
{
DatabaseTasks.Trace("RemountDatabase() failed with {0}", new object[]
{
ex3
});
ex = ex3;
}
if (ex != null)
{
throw new DatabaseRemountFailedException(database.Name, ex.ToString(), ex);
}
}
// Token: 0x06000D44 RID: 3396 RVA: 0x0003A540 File Offset: 0x00038740
public SingleCopyReplayConfiguration(IADDatabaseAvailabilityGroup dag, IADDatabase database, IADServer server, LockType lockType)
{
try
{
if (database == null)
{
throw new NullDatabaseException();
}
if (server == null)
{
throw new ErrorNullServerFromDb(database.Name);
}
this.m_database = database;
this.m_type = ReplayConfigType.SingleCopySource;
this.m_server = server;
this.m_sourceNodeFqdn = server.Fqdn;
this.m_replayState = ReplayState.GetReplayState(this.m_sourceNodeFqdn, this.m_sourceNodeFqdn, lockType, this.Identity, this.Database.Name);
this.m_activationPreference = 1;
base.PopulatePropertiesFromDag(dag);
}
finally
{
this.BuildDebugString();
}
}
public void CalculatePreferredHomeServer(Guid databaseGuid, out LegacyDN preferredRpcClientAccessServerLegacyDN, out ADObjectId preferredSiteId)
{
using (ActiveManagerPerformanceData.CalculatePreferredHomeServerDataProvider.StartRequestTimer())
{
ExTraceGlobals.ActiveManagerClientTracer.TraceFunction <Guid>((long)this.GetHashCode(), "Entering CalculatePreferredHomeServer. databaseGuid = {0}.", databaseGuid);
this.DisposeCheck();
this.m_perfCounters.CalculatePreferredHomeServerCalls.Increment();
this.m_perfCounters.CalculatePreferredHomeServerCallsPerSec.Increment();
lock (this.m_uniqueDatabasesSeen)
{
this.m_uniqueDatabasesSeen.Add(databaseGuid);
try
{
this.m_perfCounters.GetServerForDatabaseClientUniqueDatabases.RawValue = (long)this.m_uniqueDatabasesSeen.Count;
}
catch (InvalidOperationException)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceError((long)this.GetHashCode(), "Perf counters are broken. Please use lodctr to add them back");
}
}
IADDatabase databaseByGuidEx = this.GetDatabaseByGuidEx(databaseGuid, AdObjectLookupFlags.None, NullPerformanceDataLogger.Instance);
ActiveManagerImplementation.CalculatePreferredHomeServerInternal(this, databaseByGuidEx, this.m_adSession, this.m_dagLookup, this.m_casLookup, this.m_miniCasArrayLookup, out preferredRpcClientAccessServerLegacyDN, out preferredSiteId);
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <Guid, LegacyDN, ADObjectId>((long)this.GetHashCode(), "CalculatePreferredHomeServer. databaseGuid = {0}, preferredRpcClientAccessServerLegacyDN = {1}, preferredSite = {2}", databaseGuid, preferredRpcClientAccessServerLegacyDN, preferredSiteId);
ExTraceGlobals.ActiveManagerClientTracer.TraceFunction <Guid>((long)this.GetHashCode(), "Exiting CalculatePreferredHomeServer. databaseGuid = {0}", databaseGuid);
}
}
// Token: 0x0600143B RID: 5179 RVA: 0x000519C4 File Offset: 0x0004FBC4
public DatabaseReplicationNotStalledValidator(IADDatabase database, ICopyStatusClientLookup statusLookup, IMonitoringADConfig adConfig, PropertyUpdateTracker propertyUpdateTracker, bool shouldSkipEvents = true) : base(database, 0, 1, statusLookup, adConfig, propertyUpdateTracker, false, true, true, true, shouldSkipEvents)
{
if (propertyUpdateTracker == null)
{
throw new ArgumentNullException("propertyUpdateTracker shouldn't be null for DatabaseReplicationNotStalledValidator");
}
}
// Token: 0x06001319 RID: 4889 RVA: 0x0004D05A File Offset: 0x0004B25A
public AvailabilitySensor(IADDatabase database, IMonitoringADConfigProvider adConfigProvider, ICopyStatusClientLookup statusLookup, int minCopies, TimeSpan maxProbeFreq)
{
this.Database = database;
this.ADConfigProvider = adConfigProvider;
this.CopyStatusLookup = statusLookup;
this.MinAvailableCopies = minCopies;
this.MaxProbeFreq = maxProbeFreq;
}
public LogReplayScanControl(IADDatabase database, bool isLagCopy, IMonitoringADConfigProvider adConfigProvider, ICopyStatusClientLookup statusLookup, IPerfmonCounters keepingUpReader, LogReplayScanControl.ControlParameters parameters)
{
this.sensor = new AvailabilitySensor(database, adConfigProvider, statusLookup, parameters.MinAvailablePassiveCopies + 1, parameters.MaxProbeFreq);
this.isLagCopy = isLagCopy;
this.Database = database;
this.Parameters = parameters;
this.keepingUp = keepingUpReader;
}
