public DatabaseLocationInfo GetLocationInfo(Guid mdbGuid, bool bypassCache, bool ignoreSiteBoundary)
{
GetServerForDatabaseFlags getServerForDatabaseFlags = GetServerForDatabaseFlags.None;
if (ignoreSiteBoundary)
{
getServerForDatabaseFlags |= GetServerForDatabaseFlags.IgnoreAdSiteBoundary;
}
if (bypassCache)
{
getServerForDatabaseFlags |= GetServerForDatabaseFlags.ReadThrough;
}
DatabaseLocationInfo serverForDatabase;
try
{
serverForDatabase = this.activeManager.GetServerForDatabase(mdbGuid, getServerForDatabaseFlags, this.performanceDataLogger);
}
catch (DatabaseNotFoundException innerException)
{
throw new MailboxInfoStaleException(string.Format("Mailbox database guid: {0}", mdbGuid), innerException);
}
if (serverForDatabase == null || serverForDatabase.RequestResult == DatabaseLocationInfoResult.Unknown)
{
throw new DatabaseLocationUnavailableException(ServerStrings.DatabaseLocationNotAvailable(mdbGuid));
}
ExTraceGlobals.SessionTracer.TraceDebug <GetServerForDatabaseFlags, DatabaseLocationInfoResult, string>((long)this.GetHashCode(), "DatabaseLocationProvider::GetLocationInfo. flags {0}, result {1}, {2}", getServerForDatabaseFlags, serverForDatabase.RequestResult, serverForDatabase.ServerFqdn);
return(serverForDatabase);
}
public DatabaseLocationInfo GetServerForDatabase(Guid databaseId, GetServerForDatabaseFlags gsfdFlags, IPerformanceDataLogger perfLogger)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceFunction <Guid, int>((long)this.GetHashCode(), "Entering GetServerForDatabase(Guid={0}, Flags={1})", databaseId, (int)gsfdFlags);
this.DisposeCheck();
bool flag = (gsfdFlags & GetServerForDatabaseFlags.BasicQuery) != GetServerForDatabaseFlags.None;
bool flag2 = !flag;
IADDatabase database;
DatabaseLocationInfo databaseLocationInfo;
using (new StopwatchPerformanceTracker("GetServerForDatabaseGetServerNameForDatabase", perfLogger))
{
databaseLocationInfo = this.GetServerNameForDatabase(databaseId, gsfdFlags, perfLogger, out database);
}
if (databaseLocationInfo == null || string.IsNullOrEmpty(databaseLocationInfo.ServerFqdn))
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <Guid>((long)this.GetHashCode(), "Performing a BasicQuery for Database {0} failed! Falling back to a full query, which performs AD operations", databaseId);
flag2 = true;
}
if (flag2)
{
using (new StopwatchPerformanceTracker("GetServerForDatabaseGetServerInformationForDatabase", perfLogger))
{
databaseLocationInfo = this.GetServerInformationForDatabase(databaseId, database, databaseLocationInfo, gsfdFlags, perfLogger);
}
}
return(databaseLocationInfo);
}
public DatabaseLocationInfo GetServerForDatabase(Guid databaseId, bool ignoreAdSiteBoundary)
{
GetServerForDatabaseFlags getServerForDatabaseFlags = GetServerForDatabaseFlags.None;
if (ignoreAdSiteBoundary)
{
getServerForDatabaseFlags |= GetServerForDatabaseFlags.IgnoreAdSiteBoundary;
}
return(this.GetServerForDatabase(databaseId, getServerForDatabaseFlags, NullPerformanceDataLogger.Instance));
}
// Token: 0x0600003B RID: 59 RVA: 0x00002568 File Offset: 0x00000768
public string GetDatabaseServerFqdn(Guid mdbGuid, bool forceRediscovery)
{
GetServerForDatabaseFlags gsfdFlags = forceRediscovery ? GetServerForDatabaseFlags.ReadThrough : GetServerForDatabaseFlags.None;
string serverFqdn;
try
{
DatabaseLocationInfo serverForDatabase = ActiveManager.GetCachingActiveManagerInstance().GetServerForDatabase(mdbGuid, gsfdFlags);
if (serverForDatabase == null)
{
throw new MigrationMailboxDatabaseInfoNotAvailableException(mdbGuid.ToString());
}
serverFqdn = serverForDatabase.ServerFqdn;
}
catch (ObjectNotFoundException ex)
{
string text = string.Format("Server for mailbox with Guid {0} not found in ActiveManager using forceDiscovery set to {1}", mdbGuid, forceRediscovery);
this.Context.Logger.Log(MigrationEventType.Error, ex, text, new object[0]);
throw new AnchorDatabaseNotFoundTransientException(mdbGuid.ToString(), ex)
{
InternalError = text
};
}
catch (StoragePermanentException exception)
{
this.Context.Logger.Log(MigrationEventType.Error, exception, "Server for mailbox with Guid {0} not found in ActiveManager using forceDiscovery set to {1}", new object[]
{
mdbGuid,
forceRediscovery
});
throw;
}
catch (StorageTransientException exception2)
{
this.Context.Logger.Log(MigrationEventType.Error, exception2, "Server for mailbox with Guid {0} not found in ActiveManager using forceDiscovery set to {1}", new object[]
{
mdbGuid,
forceRediscovery
});
throw;
}
catch (ServerForDatabaseNotFoundException ex2)
{
string text2 = string.Format("Server for mailbox with Guid {0} not found in ActiveManager using forceDiscovery set to {1}", mdbGuid, forceRediscovery);
this.Context.Logger.Log(MigrationEventType.Error, ex2, text2, new object[0]);
throw new AnchorServerNotFoundTransientException(mdbGuid.ToString(), ex2)
{
InternalError = text2
};
}
return(serverFqdn);
}
// Token: 0x060007CD RID: 1997 RVA: 0x0001EE80 File Offset: 0x0001D080
private static bool TryGetActiveServerForDatabase(Guid databaseGuid, GetServerForDatabaseFlags flag, out DatabaseLocationInfo databaseLocationInfo, out Exception activeManagerOperationException)
{
databaseLocationInfo = null;
activeManagerOperationException = null;
ActiveManagerOperationResult activeManagerOperationResult = ActiveManager.TryGetCachedServerForDatabaseBasic(databaseGuid, flag, out databaseLocationInfo);
if (activeManagerOperationResult.Succeeded)
{
return(true);
}
activeManagerOperationException = activeManagerOperationResult.Exception;
return(false);
}
private DatabaseLocationInfo GetServerInformationForDatabase(Guid databaseId, IADDatabase database, DatabaseLocationInfo dbLocationInfo, GetServerForDatabaseFlags gsfdFlags, IPerformanceDataLogger perfLogger)
{
if (database != null && databaseId != database.Guid)
{
throw new ArgumentException("When passing in database, its GUID must match databaseId.", "database");
}
ExTraceGlobals.ActiveManagerClientTracer.TraceFunction <Guid, DatabaseLocationInfo, int>((long)this.GetHashCode(), "Entering GetServerInformationForDatabase(Guid={0}, minimalLocationInfo={1}, Flags={2})", databaseId, dbLocationInfo, (int)gsfdFlags);
this.DisposeCheck();
bool flag = (gsfdFlags & GetServerForDatabaseFlags.IgnoreAdSiteBoundary) != GetServerForDatabaseFlags.None;
bool flag2 = (gsfdFlags & GetServerForDatabaseFlags.ReadThrough) != GetServerForDatabaseFlags.None;
if (flag2 || dbLocationInfo.ServerLegacyDN == null)
{
if (database == null)
{
AdObjectLookupFlags flags = flag2 ? AdObjectLookupFlags.ReadThrough : AdObjectLookupFlags.None;
using (new StopwatchPerformanceTracker("GetServerInformationForDatabaseGetDatabaseByGuidEx", perfLogger))
{
database = this.GetDatabaseByGuidEx(databaseId, flags, perfLogger);
}
}
ActiveManagerImplementation.GetServerInformationForDatabaseInternal(database, dbLocationInfo, this.m_miniServerLookup);
}
if (dbLocationInfo != null)
{
DatabaseLocationInfoResult databaseLocationInfoResult = dbLocationInfo.RequestResult;
bool flag3 = false;
if (flag && databaseLocationInfoResult == DatabaseLocationInfoResult.SiteViolation)
{
databaseLocationInfoResult = DatabaseLocationInfoResult.Success;
flag3 = true;
}
if (flag && databaseLocationInfoResult == DatabaseLocationInfoResult.InTransitCrossSite)
{
databaseLocationInfoResult = DatabaseLocationInfoResult.InTransitSameSite;
flag3 = true;
}
ExTraceGlobals.FaultInjectionTracer.TraceTest <DatabaseLocationInfoResult>(3831901501U, ref databaseLocationInfoResult);
ExTraceGlobals.FaultInjectionTracer.TraceTest <bool>(2221288765U, ref flag3);
if (flag3)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <DatabaseLocationInfoResult, DatabaseLocationInfoResult>((long)this.GetHashCode(), "GetServerForDatabase(): At the caller's request, changing the location info's result from {0} to {1}.", dbLocationInfo.RequestResult, databaseLocationInfoResult);
dbLocationInfo = DatabaseLocationInfo.CloneDatabaseLocationInfo(dbLocationInfo, databaseLocationInfoResult);
}
}
if (ExTraceGlobals.ActiveManagerClientTracer.IsTraceEnabled(TraceType.DebugTrace))
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <Guid, DatabaseLocationInfo>((long)this.GetHashCode(), "Database Location Info ({0}) = {1}", databaseId, dbLocationInfo);
}
ExTraceGlobals.ActiveManagerClientTracer.TraceFunction <Guid>((long)this.GetHashCode(), "Exiting GetServerInformationForDatabase(Guid={0})", databaseId);
return(dbLocationInfo);
}
private DatabaseLocationInfo GetServerNameForDatabase(Guid databaseId, GetServerForDatabaseFlags gsfdFlags, IPerformanceDataLogger perfLogger, out IADDatabase database)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceFunction <Guid, GetServerForDatabaseFlags>((long)this.GetHashCode(), "Entering GetServerNameForDatabase. databaseId = {0}, gsfdFlags = {1}", databaseId, gsfdFlags);
this.DisposeCheck();
database = null;
DatabaseLocationInfo databaseLocationInfo;
if (!this.GetDbLocationInfoByRegistry(databaseId, out databaseLocationInfo))
{
bool throwOnErrors = (gsfdFlags & GetServerForDatabaseFlags.ThrowServerForDatabaseNotFoundException) != GetServerForDatabaseFlags.None;
bool flag = (gsfdFlags & GetServerForDatabaseFlags.ReadThrough) == GetServerForDatabaseFlags.ReadThrough;
if (flag)
{
this.m_perfCounters.GetServerForDatabaseClientCallsWithReadThrough.Increment();
}
if (this.m_isCacheEnabled && !flag)
{
databaseLocationInfo = this.m_dbCache.Find(databaseId);
if (databaseLocationInfo == null)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <Guid>((long)this.GetHashCode(), "Database {0} not in the cache.", databaseId);
this.m_perfCounters.GetServerForDatabaseClientCacheMisses.Increment();
}
else
{
this.m_perfCounters.GetServerForDatabaseClientCacheHits.Increment();
}
}
this.m_perfCounters.GetServerForDatabaseClientCalls.Increment();
this.m_perfCounters.GetServerForDatabaseClientCallsPerSec.Increment();
lock (this.m_uniqueDatabasesSeen)
{
this.m_uniqueDatabasesSeen.Add(databaseId);
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");
}
}
if (databaseLocationInfo == null)
{
using (new StopwatchPerformanceTracker("GetServerNameForDatabaseGetDatabaseByGuidEx", perfLogger))
{
database = this.GetDatabaseByGuidEx(databaseId, flag ? AdObjectLookupFlags.ReadThrough : AdObjectLookupFlags.None, perfLogger);
}
using (new StopwatchPerformanceTracker("GetServerNameForDatabaseLookupDatabaseAndPossiblyPopulateCache", perfLogger))
{
databaseLocationInfo = this.LookupDatabaseAndPossiblyPopulateCache(database, throwOnErrors);
}
}
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <Guid, DatabaseLocationInfo>((long)this.GetHashCode(), "Database Location Info ({0}) = {1}", databaseId, databaseLocationInfo);
}
lock (this.m_uniqueServersSeen)
{
if (databaseLocationInfo != null && databaseLocationInfo.ServerFqdn != null)
{
this.m_uniqueServersSeen.Add(databaseLocationInfo.ServerFqdn);
}
try
{
this.m_perfCounters.GetServerForDatabaseClientUniqueServers.RawValue = (long)this.m_uniqueServersSeen.Count;
}
catch (InvalidOperationException)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceError((long)this.GetHashCode(), "Perf counters are broken. Please use lodctr to add them back");
}
}
ExTraceGlobals.ActiveManagerClientTracer.TraceFunction <Guid>((long)this.GetHashCode(), "Exiting GetServerNameForDatabase. databaseId = {0}", databaseId);
return(databaseLocationInfo);
}
public DatabaseLocationInfo GetServerForDatabase(Guid databaseId, GetServerForDatabaseFlags gsfdFlags)
{
return(this.GetServerForDatabase(databaseId, gsfdFlags, NullPerformanceDataLogger.Instance));
}
public static ActiveManagerOperationResult TryGetCachedServerForDatabaseBasic(Guid mdbGuid, GetServerForDatabaseFlags gsfdFlags, out DatabaseLocationInfo databaseLocationInfo)
{
Exception ex = null;
databaseLocationInfo = null;
ActiveManager cachingActiveManagerInstance = ActiveManager.GetCachingActiveManagerInstance();
try
{
databaseLocationInfo = cachingActiveManagerInstance.GetServerForDatabase(mdbGuid, gsfdFlags, NullPerformanceDataLogger.Instance);
return(new ActiveManagerOperationResult(true, ex));
}
catch (DatabaseNotFoundException ex2)
{
ex = ex2;
}
catch (ObjectNotFoundException ex3)
{
ex = ex3;
}
catch (StoragePermanentException ex4)
{
ex = ex4;
}
catch (StorageTransientException ex5)
{
ex = ex5;
}
catch (ServerForDatabaseNotFoundException ex6)
{
ex = ex6;
}
return(new ActiveManagerOperationResult(false, ex));
}
public static DatabaseInformation FindServerForMdb(Guid mdbGuid, string dcName, NetworkCredential cred, FindServerFlags flags)
{
Guid systemMailboxGuid = Guid.Empty;
if (flags.HasFlag(FindServerFlags.FindSystemMailbox))
{
systemMailboxGuid = MapiUtils.GetSystemMailboxGuid(mdbGuid, dcName, cred, flags);
}
if (cred == null)
{
try
{
GetServerForDatabaseFlags getServerForDatabaseFlags = GetServerForDatabaseFlags.IgnoreAdSiteBoundary;
if (flags.HasFlag(FindServerFlags.ForceRediscovery))
{
MrsTracer.Common.Debug("Looking up MDB {0} with rediscovery", new object[]
{
mdbGuid
});
getServerForDatabaseFlags |= GetServerForDatabaseFlags.ReadThrough;
}
DatabaseLocationInfo serverForDatabase = ActiveManager.GetCachingActiveManagerInstance().GetServerForDatabase(mdbGuid, getServerForDatabaseFlags);
if (serverForDatabase != null)
{
return(DatabaseInformation.FromDatabaseLocationInfo(mdbGuid, serverForDatabase, systemMailboxGuid));
}
}
catch (ObjectNotFoundException)
{
}
MrsTracer.Common.Debug("ActiveManager was unable to locate MDB {0}, will search AD instead.", new object[]
{
mdbGuid
});
}
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(dcName, true, ConsistencyMode.PartiallyConsistent, cred, ADSessionSettings.FromRootOrgScopeSet(), 686, "FindServerForMdb", "f:\\15.00.1497\\sources\\dev\\mrs\\src\\Common\\MapiUtils.cs");
Database database = topologyConfigurationSession.FindDatabaseByGuid <Database>(mdbGuid);
if (database == null)
{
MrsTracer.Common.Error("Unable to locate MDB by guid {0}", new object[]
{
mdbGuid
});
if (!flags.HasFlag(FindServerFlags.AllowMissing))
{
throw new DatabaseNotFoundByGuidPermanentException(mdbGuid);
}
return(DatabaseInformation.Missing(mdbGuid, PartitionId.LocalForest.ForestFQDN));
}
else
{
PropertyDefinition[] properties = new PropertyDefinition[]
{
ServerSchema.ExchangeLegacyDN,
ServerSchema.Fqdn,
ServerSchema.ServerSite,
ServerSchema.VersionNumber,
ActiveDirectoryServerSchema.MailboxRelease
};
MiniServer miniServer = topologyConfigurationSession.ReadMiniServer(database.Server, properties);
if (miniServer != null)
{
return(DatabaseInformation.FromAD(database, miniServer, systemMailboxGuid));
}
MrsTracer.Common.Error("Unable to locate DB server {0}", new object[]
{
database.Server.DistinguishedName
});
if ((flags & FindServerFlags.AllowMissing) == FindServerFlags.None)
{
throw new UnexpectedErrorPermanentException(-2147221233);
}
return(DatabaseInformation.Missing(mdbGuid, PartitionId.LocalForest.ForestFQDN));
}
}
