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);
}
internal void UpdateInPlace(string serverFqdn, string serverLegacyDN, string lastMountedServerFqdn, string lastMountedServerLegacyDN, string databaseLegacyDN, string rpcClientAcessServerLegacyDN, string databaseName, bool databaseIsPublic, bool databaseIsRestored, Guid homePublicFolderDatabaseGuid, DateTime mountedTime, Guid?serverGuid, ADObjectId serverSite, ServerVersion serverVersion, MailboxRelease mailboxRelease, DatabaseLocationInfoResult requestResult, bool isDatabaseHighlyAvailable)
{
if (serverFqdn != null && serverFqdn.Length == 0)
{
throw new ArgumentException("serverFqdn is empty", "serverFqdn");
}
if (serverLegacyDN != null && serverLegacyDN.Length == 0)
{
throw new ArgumentException("serverLegacyDN is empty", "serverLegacyDN");
}
if (lastMountedServerFqdn != null && lastMountedServerFqdn.Length == 0)
{
throw new ArgumentException("lastMountedServerFqdn is empty", "lastMountedServerFqdn");
}
if (lastMountedServerLegacyDN != null && lastMountedServerLegacyDN.Length == 0)
{
throw new ArgumentException("lastMountedServerLegacyDN is empty", "lastMountedServerLegacyDN");
}
this.ServerFqdn = serverFqdn;
this.ServerLegacyDN = serverLegacyDN;
this.DatabaseLegacyDN = databaseLegacyDN;
this.RpcClientAccessServerLegacyDN = rpcClientAcessServerLegacyDN;
this.DatabaseName = databaseName;
this.DatabaseIsPublic = databaseIsPublic;
this.DatabaseIsRestored = databaseIsRestored;
this.HomePublicFolderDatabaseGuid = homePublicFolderDatabaseGuid;
this.serverGuid = serverGuid;
this.ServerSite = serverSite;
this.AdminDisplayVersion = serverVersion;
this.MailboxRelease = mailboxRelease;
this.IsDatabaseHighlyAvailable = isDatabaseHighlyAvailable;
this.LastMountedServerFqdn = (lastMountedServerFqdn ?? serverFqdn);
this.LastMountedServerLegacyDN = (lastMountedServerLegacyDN ?? serverLegacyDN);
this.MountedTime = mountedTime;
this.RequestResult = requestResult;
}
internal DatabaseLocationInfo(string serverFqdn, string serverLegacyDN, string lastMountedServerFqdn, string lastMountedServerLegacyDN, string databaseLegacyDN, string rpcClientAcessServerLegacyDN, string databaseName, bool databaseIsPublic, bool databaseIsRestored, Guid homePublicFolderDatabaseGuid, DateTime mountedTime, Guid?serverGuid, ADObjectId serverSite, ServerVersion serverVersion, MailboxRelease mailboxRelease, DatabaseLocationInfoResult requestResult, bool isDatabaseHighlyAvailable)
{
this.UpdateInPlace(serverFqdn, serverLegacyDN, lastMountedServerFqdn, lastMountedServerLegacyDN, databaseLegacyDN, rpcClientAcessServerLegacyDN, databaseName, databaseIsPublic, databaseIsRestored, homePublicFolderDatabaseGuid, mountedTime, serverGuid, serverSite, serverVersion, mailboxRelease, requestResult, isDatabaseHighlyAvailable);
}
internal static DatabaseLocationInfo CloneDatabaseLocationInfo(DatabaseLocationInfo right, DatabaseLocationInfoResult requestResult)
{
return(new DatabaseLocationInfo(right.ServerFqdn, right.ServerLegacyDN, right.LastMountedServerFqdn, right.LastMountedServerLegacyDN, right.DatabaseLegacyDN, right.RpcClientAccessServerLegacyDN, right.DatabaseName, right.DatabaseIsPublic, right.DatabaseIsRestored, right.HomePublicFolderDatabaseGuid, right.MountedTime, right.serverGuid, right.ServerSite, right.AdminDisplayVersion, right.MailboxRelease, requestResult, right.IsDatabaseHighlyAvailable));
}
internal static DatabaseLocationInfo GetServerNameForDatabaseInternal(IADDatabase database, NetworkCredential networkCredential, IFindAdObject <IADDatabaseAvailabilityGroup> dagLookup, IFindMiniServer findMiniServer, ActiveManagerClientPerfmonInstance perfCounters, bool throwOnErrors, bool isService)
{
Guid guid = database.Guid;
string serverFqdn = null;
string lastMountedServerFqdn = null;
bool isDatabaseHighlyAvailable = false;
DateTime mountedTime = DateTime.MinValue;
DatabaseLocationInfoResult requestResult = DatabaseLocationInfoResult.Unknown;
ServerVersion serverVersion = null;
if (ActiveManagerImplementation.TestHookHangGsfdForMilliseconds > 0)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <int>(0L, "TestHook is hanging GetServerNameForDatabaseInternal for {0} milliseconds", ActiveManagerImplementation.TestHookHangGsfdForMilliseconds);
Thread.Sleep(ActiveManagerImplementation.TestHookHangGsfdForMilliseconds);
}
if (Interlocked.Increment(ref ActiveManagerImplementation.NumberOfConcurrentRPCthreads) <= 3000)
{
try
{
if (!ActiveManagerImplementation.IsActiveManagerRpcSupported(database))
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <string>(0L, "Database {0} doesn't support RPC's for ActiveManager", database.Name);
}
else
{
try
{
ActiveManagerImplementation.s_perfCounters.GetServerForDatabaseClientRpcCalls.Increment();
AmDbStatusInfo2 amDbStatusInfo = AmRpcClientHelper.RpcchGetServerForDatabase(database, networkCredential, dagLookup, findMiniServer, perfCounters, isService, out serverVersion);
isDatabaseHighlyAvailable = (amDbStatusInfo.IsHighlyAvailable != 0);
serverFqdn = amDbStatusInfo.MasterServerFqdn;
lastMountedServerFqdn = amDbStatusInfo.LastMountedServerFqdn;
mountedTime = amDbStatusInfo.MountedTime;
requestResult = DatabaseLocationInfoResult.Success;
}
catch (AmDatabaseNeverMountedException innerException)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <string>(0L, "Database {0} was never mounted on any of the servers (defaulting to owner server)", string.Empty);
if (throwOnErrors)
{
throw new ServerForDatabaseNotFoundException(database.Name, guid.ToString(), innerException);
}
}
catch (AmServerException ex)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <string>(0L, "Encountered AM Server exception: {0} (defaulting to owner server)", ex.Message);
if (throwOnErrors)
{
throw new ServerForDatabaseNotFoundException(database.Name, guid.ToString(), ex);
}
}
catch (AmServerTransientException ex2)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <string>(0L, "Encountered AM Server exception: {0} (defaulting to owner server)", ex2.Message);
if (throwOnErrors)
{
throw new ServerForDatabaseNotFoundException(database.Name, guid.ToString(), ex2);
}
}
}
goto IL_1CF;
}
finally
{
Interlocked.Decrement(ref ActiveManagerImplementation.NumberOfConcurrentRPCthreads);
}
}
Interlocked.Decrement(ref ActiveManagerImplementation.NumberOfConcurrentRPCthreads);
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <int>(0L, "Maximum number ({0}) of concurrent RPC threads reached.", 3000);
if (throwOnErrors)
{
throw new ServerForDatabaseNotFoundException(database.Name, guid.ToString(), new TooManyActiveManagerClientRPCsException(3000));
}
IL_1CF:
return(new DatabaseLocationInfo(serverFqdn, null, lastMountedServerFqdn, null, null, null, database.Name, false, database.Recovery, Guid.Empty, mountedTime, null, null, serverVersion, MailboxRelease.None, requestResult, isDatabaseHighlyAvailable));
}
internal static void GetServerInformationForDatabaseInternal(IADDatabase database, DatabaseLocationInfo minimalLocationInfo, IFindMiniServer findMiniServer)
{
Guid guid = database.Guid;
string lastMountedServerFqdn = minimalLocationInfo.LastMountedServerFqdn;
IADServer iadserver = null;
ADObjectId adobjectId = null;
string serverFqdn = minimalLocationInfo.ServerFqdn;
if (serverFqdn != null)
{
iadserver = findMiniServer.FindMiniServerByFqdn(serverFqdn);
}
else
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <string>(0L, "GetServerInformationForDatabaseInternal({0}) is falling back to database.Server from AD, which may be stale.", database.Name);
iadserver = findMiniServer.ReadMiniServerByObjectId(database.Server);
}
if (iadserver == null)
{
throw new UnableToFindServerForDatabaseException(database.Name, guid.ToString());
}
ADObjectId serverSiteFromMiniServer = ActiveManagerUtil.GetServerSiteFromMiniServer(iadserver);
string fqdn = iadserver.Fqdn;
if (iadserver.IsExchange2007OrLater && (serverSiteFromMiniServer == null || string.IsNullOrEmpty(fqdn) || (iadserver.IsExchange2007OrLater && !iadserver.IsMailboxServer)))
{
throw new UnableToFindServerForDatabaseException(database.Name, guid.ToString());
}
if (string.Equals(lastMountedServerFqdn, serverFqdn, StringComparison.OrdinalIgnoreCase))
{
adobjectId = iadserver.Id;
}
else
{
adobjectId = ActiveManagerImplementation.TryGetServerIdByFqdn(findMiniServer, lastMountedServerFqdn);
}
if (adobjectId == null)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <ADObjectId>(0L, "lastMountedServer was null. Setting to the current server ({0}).", iadserver.Id);
adobjectId = iadserver.Id;
}
DatabaseLocationInfoResult requestResult = DatabaseLocationInfoResult.Success;
IADServer iadserver2 = null;
if (iadserver.Id.Equals(adobjectId))
{
iadserver2 = iadserver;
}
else
{
try
{
iadserver2 = findMiniServer.ReadMiniServerByObjectId(adobjectId);
}
catch (ADTransientException arg)
{
ActiveManagerImplementation.Tracer.TraceDebug <ADTransientException>(0L, "ReadMiniServer() threw an ADTransientException: {0}", arg);
}
}
IADToplogyConfigurationSession adSession = findMiniServer.AdSession;
IADSite iadsite = ActiveManagerImplementation.RetrieveLocalSite(adSession);
if (iadsite == null)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug(0L, "GetServerForDatabase detected an Unknown state! adSession.GetLocalSite() is null.");
requestResult = DatabaseLocationInfoResult.Unknown;
}
else if (iadserver2 == null)
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <ADObjectId>(0L, "GetServerForDatabase detected an Unknown state! lastMountedServerId ({0}) could not be resolved.", adobjectId);
requestResult = DatabaseLocationInfoResult.Unknown;
}
else if (!iadserver.Id.Equals(adobjectId))
{
ADObjectId serverSiteFromMiniServer2 = ActiveManagerUtil.GetServerSiteFromMiniServer(iadserver2);
if (serverSiteFromMiniServer == serverSiteFromMiniServer2 || (serverSiteFromMiniServer != null && serverSiteFromMiniServer.Equals(serverSiteFromMiniServer2)))
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug(0L, "GetServerForDatabase detected InTransitSameSite! masterServer (name={0},site={1}), lastMountedServer (name={2},site={3}.", new object[]
{
iadserver.Id,
serverSiteFromMiniServer,
adobjectId,
serverSiteFromMiniServer2
});
requestResult = DatabaseLocationInfoResult.InTransitSameSite;
}
else
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug(0L, "GetServerForDatabase detected InTransitCrossSite! masterServer (name={0},site={1}), lastMountedServer (name={2},site={3}.", new object[]
{
iadserver.Id,
serverSiteFromMiniServer,
adobjectId,
serverSiteFromMiniServer2
});
requestResult = DatabaseLocationInfoResult.InTransitCrossSite;
}
}
else if (!iadsite.Id.Equals(serverSiteFromMiniServer))
{
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <ADObjectId, ADObjectId>(0L, "GetServerForDatabase detected a SiteViolation! GetLocalSite().Id != serverSiteId ({0} != {1}).", iadsite.Id, serverSiteFromMiniServer);
requestResult = DatabaseLocationInfoResult.SiteViolation;
}
string exchangeLegacyDN = iadserver.ExchangeLegacyDN;
ServerVersion adminDisplayVersion = iadserver.AdminDisplayVersion;
Guid objectGuid = iadserver.Id.ObjectGuid;
string exchangeLegacyDN2 = iadserver2.ExchangeLegacyDN;
iadserver2 = null;
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <Guid>(0L, "GetServerInformationForDatabaseInternal: Updating the location information for {0} in place.", guid);
ADObjectId mailboxPublicFolderDatabase = database.MailboxPublicFolderDatabase;
minimalLocationInfo.UpdateInPlace(fqdn, exchangeLegacyDN, minimalLocationInfo.LastMountedServerFqdn, exchangeLegacyDN2, database.ExchangeLegacyDN, database.RpcClientAccessServerLegacyDN, database.Name, database.IsPublicFolderDatabase, database.Recovery, (mailboxPublicFolderDatabase != null) ? mailboxPublicFolderDatabase.ObjectGuid : Guid.Empty, minimalLocationInfo.MountedTime, new Guid?(objectGuid), serverSiteFromMiniServer, adminDisplayVersion, iadserver.MailboxRelease, requestResult, minimalLocationInfo.IsDatabaseHighlyAvailable);
}