// Token: 0x060005DF RID: 1503 RVA: 0x00020D48 File Offset: 0x0001EF48
private bool TryGetMiniServerFromPartitionId(string partitionId, out MiniServer server)
{
bool result;
try
{
if (CafeConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).UseServerNameAsPartitionId.Enabled)
{
bool flag;
server = ServersCache.GetServerOrDCByName(partitionId, ref flag);
}
else
{
Guid guid;
if (!Guid.TryParse(partitionId, out guid))
{
base.Logger.AppendGenericError("Get server by partitionID exception", "Not a GUID");
server = null;
return(false);
}
bool flag;
server = ServersCache.GetServerOrDCByObjectGuid(guid, ref flag);
}
result = true;
}
catch (ObjectNotFoundException ex)
{
base.Logger.AppendGenericError("Get server by partitionID exception", ex.ToString());
server = null;
result = false;
}
return(result);
}
internal static BackEndServer GetDeterministicBackEndServer <ServiceType>(BackEndServer mailboxServer, string identifier, ClientAccessType clientAccessType) where ServiceType : HttpService
{
if (mailboxServer == null)
{
throw new ArgumentNullException("mailboxServer");
}
if (string.IsNullOrEmpty(identifier))
{
throw new ArgumentNullException("identifier");
}
if (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled && VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Cafe.ServersCache.Enabled)
{
MiniServer deterministicBackEndServerFromSameSite = ServersCache.GetDeterministicBackEndServerFromSameSite(mailboxServer.Fqdn, Server.E15MinVersion, identifier, false);
return(new BackEndServer(deterministicBackEndServerFromSameSite.Fqdn, deterministicBackEndServerFromSameSite.VersionNumber));
}
HttpProxyBackEndHelper.TopologyWithSites completeServiceTopologyWithSites = HttpProxyBackEndHelper.GetCompleteServiceTopologyWithSites(mailboxServer.Fqdn);
HttpService[] array = (HttpService[])HttpProxyBackEndHelper.FindAcceptableBackEndService <ServiceType>(completeServiceTopologyWithSites, clientAccessType, (int x) => x >= Server.E15MinVersion);
if (array.Length > 0)
{
int num = HttpProxyBackEndHelper.ComputeIndex(identifier, array.Length);
ExTraceGlobals.CafeTracer.TraceDebug <int, string, int>(0L, "[HttpProxyBackEndHelper.GetDeterministicBackEndServer] Buckets: {0} Identifier: {1} Index: {2}", array.Length, identifier, num);
return(new BackEndServer(array[num].ServerFullyQualifiedDomainName, array[num].ServerVersionNumber));
}
throw new ServerNotFoundException("Unable to find proper HTTP service.");
}
private void CheckDagMembership()
{
ADObjectId databaseAvailabilityGroup = this.m_server.DatabaseAvailabilityGroup;
if (ADObjectId.IsNullOrEmpty(databaseAvailabilityGroup))
{
base.WriteError(new AddDatabaseCopyNewCopyMustBeInDagException(this.m_server.Name, this.DataObject.Name), ErrorCategory.InvalidArgument, null);
}
DatabaseAvailabilityGroup databaseAvailabilityGroup2 = (DatabaseAvailabilityGroup)base.DataSession.Read <DatabaseAvailabilityGroup>(databaseAvailabilityGroup);
if (databaseAvailabilityGroup2 == null)
{
base.WriteError(new AddDatabaseCopyNewCopyMustBeInDagException(this.m_server.Name, this.DataObject.Name), ErrorCategory.InvalidArgument, null);
}
if (ThirdPartyReplicationMode.Enabled == databaseAvailabilityGroup2.ThirdPartyReplication)
{
this.m_isThirdPartyReplicationEnabled = true;
}
ITopologyConfigurationSession topologyConfigurationSession = (ITopologyConfigurationSession)base.DataSession;
foreach (DatabaseCopy databaseCopy in this.m_databaseCopies)
{
ADObjectId hostServer = databaseCopy.HostServer;
MiniServer miniServer = topologyConfigurationSession.ReadMiniServer(hostServer, AddMailboxDatabaseCopy.s_miniServerProperties);
ADObjectId databaseAvailabilityGroup3 = miniServer.DatabaseAvailabilityGroup;
if (ADObjectId.IsNullOrEmpty(databaseAvailabilityGroup3))
{
base.WriteError(new AddDatabaseCopyAllCopiesMustBeInTheDagException(this.DataObject.Name, this.m_server.Name, databaseAvailabilityGroup2.Name, miniServer.Name), ErrorCategory.InvalidArgument, null);
}
else if (!databaseAvailabilityGroup3.Equals(databaseAvailabilityGroup))
{
base.WriteError(new AddDatabaseCopyAllCopiesMustBeInSameDagException(this.DataObject.Name, this.m_server.Name, databaseAvailabilityGroup2.Name, miniServer.Name, databaseAvailabilityGroup3.Name), ErrorCategory.InvalidArgument, null);
}
}
}
public static int?LookupVersion(string server)
{
int versionNumber;
if (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled && VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Cafe.ServersCache.Enabled)
{
try
{
bool flag;
MiniServer serverByFQDN = ServersCache.GetServerByFQDN(server, out flag);
versionNumber = serverByFQDN.VersionNumber;
goto IL_90;
}
catch (LocalServerNotFoundException)
{
return(null);
}
}
ServiceTopology currentServiceTopology = ServiceTopology.GetCurrentServiceTopology("f:\\15.00.1497\\sources\\dev\\cafe\\src\\Common\\Misc\\ServerLookup.cs", "LookupVersion", 45);
if (!currentServiceTopology.TryGetServerVersion(server, out versionNumber, "f:\\15.00.1497\\sources\\dev\\cafe\\src\\Common\\Misc\\ServerLookup.cs", "LookupVersion", 47))
{
return(null);
}
IL_90:
return(new int?(versionNumber));
}
internal static void UpdateServerLegdnForDatabaseSite(Task.TaskErrorLoggingDelegate writeErrorDelegate, Task.TaskVerboseLoggingDelegate writeVerboseDelegate, ITopologyConfigurationSession adSession, DatabaseCopy dbCopy)
{
ADObjectId hostServer = dbCopy.HostServer;
PropertyDefinition[] properties = new PropertyDefinition[]
{
ServerSchema.ServerSite
};
MiniServer miniServer = adSession.ReadMiniServer(hostServer, properties);
if (miniServer == null)
{
writeErrorDelegate(new ADServerNotFoundException(hostServer.ToString()), ErrorCategory.InvalidArgument, null);
}
IADToplogyConfigurationSession adSession2 = ADSessionFactory.CreateWrapper(adSession);
SimpleAdObjectLookup <IADClientAccessArray> findClientAccessArray = new SimpleAdObjectLookup <IADClientAccessArray>(adSession2);
SimpleMiniClientAccessServerOrArrayLookup findMiniClientAccessServer = new SimpleMiniClientAccessServerOrArrayLookup(adSession);
ADObjectId serverSite = miniServer.ServerSite;
LegacyDN legacyDN = ActiveManagerImplementation.FindClientAccessArrayOrServerFromSite(serverSite, miniServer.Id, findClientAccessArray, findMiniClientAccessServer, AdObjectLookupFlags.ReadThrough);
ADObjectId parent = dbCopy.Id.Parent;
Database database = adSession.Read <Database>(parent);
if (legacyDN != null)
{
LegacyDN databaseLegacyDNFromRcaLegacyDN = Database.GetDatabaseLegacyDNFromRcaLegacyDN(legacyDN, database.IsPublicFolderDatabase);
database.ExchangeLegacyDN = databaseLegacyDNFromRcaLegacyDN.ToString();
writeVerboseDelegate(Strings.UpdatingLegDnForDatabaseToServer(database.Name, legacyDN.ToString(), legacyDN.ToString()));
adSession.Save(database);
return;
}
ExTraceGlobals.CmdletsTracer.TraceDebug <ADObjectId>(0L, "Could not find a new CAS machines for site '{0}'. Leaving the database's legdn unchanged.", serverSite);
}
private bool ServerHasMailboxRole(string serverName)
{
MiniServer miniServer = null;
try
{
miniServer = this.m_adSession.FindMiniServerByFqdn(SharedHelper.GetFqdnNameFromNode(serverName), FileShareWitness.s_miniServerProperties);
}
catch (ADTransientException ex)
{
TaskLogger.Trace("Attempt to check mailbox role for server {0} failed. Specific error: {1}", new object[]
{
serverName,
ex
});
}
catch (ADExternalException ex2)
{
TaskLogger.Trace("Attempt to check mailbox role for server {0} failed. Specific error: {1}", new object[]
{
serverName,
ex2
});
}
catch (ADOperationException ex3)
{
TaskLogger.Trace("Attempt to check mailbox role for server {0} failed. Specific error: {1}", new object[]
{
serverName,
ex3
});
}
return(miniServer != null && miniServer.IsMailboxServer);
}
public static ADServerWrapper CreateWrapper(MiniServer server)
{
if (server == null)
{
return(null);
}
return(new ADServerWrapper(server));
}
internal static BackEndServer GetAnyBackEndServer(bool useServersCache)
{
if (useServersCache)
{
MiniServer anyBackEndServerWithMinVersion = ServersCache.GetAnyBackEndServerWithMinVersion(Server.E15MinVersion);
return(new BackEndServer(anyBackEndServerWithMinVersion.Fqdn, anyBackEndServerWithMinVersion.VersionNumber));
}
return(HttpProxyBackEndHelper.GetAnyBackEndServerForVersion <WebServicesService>(new ServerVersion(Server.E15MinVersion), false, ClientAccessType.InternalNLBBypass, false));
}
private void RunSourceConfigurationUpdaterRpc()
{
string text = this.DataObject.ServerName;
MiniServer miniServer = (MiniServer)base.DataSession.Read <MiniServer>(this.DataObject.Server);
if (miniServer == null)
{
this.WriteWarning(Strings.ErrorMailboxServerNotFound(text));
return;
}
text = miniServer.Fqdn;
DatabaseTasksHelper.RunConfigurationUpdaterRpc(text, this.DataObject, miniServer.AdminDisplayVersion, ReplayConfigChangeHints.DbCopyAdded, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning));
}
public static RemoteSiteInCurrentOrgTrackingAuthority Create(ADObjectId siteADObjectId, DirectoryContext directoryContext, int minServerVersionRequested, bool useServersCache)
{
string text = ServerCache.Instance.GetDefaultDomain(directoryContext.OrganizationId);
int version = 0;
Uri uri = null;
if (useServersCache)
{
TraceWrapper.SearchLibraryTracer.TraceDebug <ADObjectId>(0, "Creating remote tracking authority via ServersCache for site: {0}", siteADObjectId);
try
{
MiniServer anyBackEndServerFromASite = ServersCache.GetAnyBackEndServerFromASite(siteADObjectId, minServerVersionRequested, false);
version = anyBackEndServerFromASite.VersionNumber;
TraceWrapper.SearchLibraryTracer.TraceDebug <string, ServerVersion>(0, "Found remote server {0} running {1}.", anyBackEndServerFromASite.Fqdn, anyBackEndServerFromASite.AdminDisplayVersion);
if (anyBackEndServerFromASite.MajorVersion >= 15)
{
BackEndServer backEndServer = new BackEndServer(anyBackEndServerFromASite.Fqdn, version);
uri = BackEndLocator.GetBackEndWebServicesUrl(backEndServer);
}
else
{
TraceWrapper.SearchLibraryTracer.TraceDebug(0, "Server found was E14, finding new tracking authority via ServiceTopology.", new object[0]);
uri = ServerCache.Instance.GetCasServerUri(siteADObjectId, minServerVersionRequested, out version);
}
goto IL_118;
}
catch (BackEndLocatorException ex)
{
TraceWrapper.SearchLibraryTracer.TraceError <string>(0, "Failed to acquire EWS URI from BackEndLocator with exception: {0}", ex.ToString());
TrackingFatalException.RaiseET(ErrorCode.CASUriDiscoveryFailure, siteADObjectId.ToString());
goto IL_118;
}
catch (ServerHasNotBeenFoundException ex2)
{
TraceWrapper.SearchLibraryTracer.TraceError <string>(0, "Failed to locate remote backend server from ServersCache with exception: {0}", ex2.ToString());
TrackingFatalException.RaiseET(ErrorCode.CASUriDiscoveryFailure, siteADObjectId.ToString());
goto IL_118;
}
}
TraceWrapper.SearchLibraryTracer.TraceDebug(0, "Creating remote tracking authority via ServiceTopology.", new object[0]);
uri = ServerCache.Instance.GetCasServerUri(siteADObjectId, minServerVersionRequested, out version);
IL_118:
if (null == uri)
{
TraceWrapper.SearchLibraryTracer.TraceError(0, "No suitable authority URI found.", new object[0]);
TrackingFatalException.RaiseET(ErrorCode.CASUriDiscoveryFailure, siteADObjectId.ToString());
}
return(new RemoteSiteInCurrentOrgTrackingAuthority(text, TrackingAuthorityKind.RemoteSiteInCurrentOrg, siteADObjectId, uri, version));
}
private static int GetNumberOfDatacenters(ITopologyConfigurationSession taskSession, Database database)
{
HashSet <ADObjectId> hashSet = new HashSet <ADObjectId>();
DatabaseCopy[] databaseCopies = database.GetDatabaseCopies();
foreach (DatabaseCopy databaseCopy in databaseCopies)
{
MiniServer miniServer = taskSession.ReadMiniServer(databaseCopy.HostServer, DatabaseTasksHelper.s_propertiesNeededFromServer);
if (miniServer.ServerSite != null)
{
hashSet.Add(miniServer.ServerSite);
}
}
return(hashSet.Count);
}
private DirectoryServer GetServer(ADObjectId objectId)
{
MiniServer miniServer = this.ConfigurationSession.ReadMiniServer(objectId, new ADPropertyDefinition[]
{
ServerSchema.Fqdn,
ADObjectSchema.Id,
ADObjectSchema.Name
});
if (miniServer == null)
{
throw new ServerNotFoundException(objectId.ObjectGuid.ToString());
}
return(new DirectoryServer(this, DirectoryIdentity.CreateFromADObjectId(objectId, DirectoryObjectType.Server), miniServer.Fqdn));
}
internal static List <ADObjectId> GetSitesForDag(DatabaseAvailabilityGroup dag)
{
if (dag == null)
{
throw new ArgumentNullException("dag");
}
HashSet <ADObjectId> hashSet = new HashSet <ADObjectId>();
foreach (ADObjectId entryId in dag.Servers)
{
MiniServer miniServer = ((ITopologyConfigurationSession)dag.Session).ReadMiniServer(entryId, DatabaseAvailabilityGroupAction.PropertiesNeededFromServer);
ADObjectId serverSite = miniServer.ServerSite;
hashSet.Add(serverSite);
}
return(hashSet.ToList <ADObjectId>());
}
// Token: 0x06000675 RID: 1653 RVA: 0x00017E78 File Offset: 0x00016078
bool IWritableAD.SetDatabaseLegacyDnAndOwningServer(Guid mdbGuid, AmServerName lastMountedServerName, AmServerName masterServerName, bool isForceUpdate)
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(false, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 43, "SetDatabaseLegacyDnAndOwningServer", "f:\\15.00.1497\\sources\\dev\\cluster\\src\\Shared\\WritableADHelper.cs");
Database database = topologyConfigurationSession.FindDatabaseByGuid <Database>(mdbGuid);
if (database == null)
{
AmTrace.Error("Failed to find Db using dbGuid {0}", new object[]
{
mdbGuid
});
return(false);
}
MiniServer miniServer = topologyConfigurationSession.FindMiniServerByName(masterServerName.NetbiosName, WritableADHelper.s_propertiesNeededFromServer);
if (miniServer == null)
{
AmTrace.Error("Failed to find Server using {0}", new object[]
{
masterServerName
});
return(false);
}
if (isForceUpdate || !database.Server.Equals(miniServer.Id))
{
MiniServer sourceServer = null;
if (!AmServerName.IsNullOrEmpty(lastMountedServerName))
{
sourceServer = topologyConfigurationSession.FindMiniServerByName(lastMountedServerName.NetbiosName, WritableADHelper.s_propertiesNeededFromServer);
}
AmTrace.Debug("SetDatabaseLegacyDnAndOwningServer. Database '{0}', legdn='{1}'. Setting owning server: '{2}'.", new object[]
{
database.Name,
database.ExchangeLegacyDN,
miniServer.Id
});
database.Server = miniServer.Id;
WritableADHelper.SaveDatabasePropertiesOnMultipleServerSites(topologyConfigurationSession, database, sourceServer, miniServer, true);
return(true);
}
AmTrace.Debug("Skipped to update legacy dn and owning server for database '{0}' since they are up to date. (owningserver={1})", new object[]
{
database.Name,
database.Server
});
return(false);
}
public static DatabaseInformation FromAD(Database db, MiniServer server, Guid systemMailboxGuid)
{
MailboxRelease mailboxRelease;
return(new DatabaseInformation
{
MdbGuid = db.Guid,
DatabaseName = db.Name,
ServerDN = server.ExchangeLegacyDN,
ServerFqdn = server.Fqdn,
ServerGuid = server.Guid,
ServerSite = server.ServerSite,
ServerVersion = server.VersionNumber,
SystemMailboxGuid = systemMailboxGuid,
MailboxRelease = (Enum.TryParse <MailboxRelease>((string)server[ActiveDirectoryServerSchema.MailboxRelease], true, out mailboxRelease) ? mailboxRelease : MailboxRelease.None)
});
}
// Token: 0x06000676 RID: 1654 RVA: 0x00017FA4 File Offset: 0x000161A4
void IWritableAD.ResetAllowFileRestoreDsFlag(Guid mdbGuid, AmServerName lastMountedServerName, AmServerName masterServerName)
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(false, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 108, "ResetAllowFileRestoreDsFlag", "f:\\15.00.1497\\sources\\dev\\cluster\\src\\Shared\\WritableADHelper.cs");
Database database = topologyConfigurationSession.FindDatabaseByGuid <Database>(mdbGuid);
if (database == null)
{
AmTrace.Error("Failed to find Db using dbGuid {0}", new object[]
{
mdbGuid
});
return;
}
if (!database.AllowFileRestore)
{
AmTrace.Debug("Skipped to update legacy AllowFileRestore database '{0}'.)", new object[]
{
database.Name
});
return;
}
MiniServer miniServer = topologyConfigurationSession.FindMiniServerByName(masterServerName.NetbiosName, WritableADHelper.s_propertiesNeededFromServer);
if (miniServer == null)
{
AmTrace.Error("Failed to find Server using {0}", new object[]
{
masterServerName
});
return;
}
MiniServer sourceServer = null;
if (!AmServerName.IsNullOrEmpty(lastMountedServerName))
{
sourceServer = topologyConfigurationSession.FindMiniServerByName(lastMountedServerName.NetbiosName, WritableADHelper.s_propertiesNeededFromServer);
}
AmTrace.Debug("Reset AllowFileRestore. Database '{0}', legdn='{1}'. Setting owning server: '{2}'.", new object[]
{
database.Name,
database.ExchangeLegacyDN,
miniServer.Id
});
database.AllowFileRestore = false;
WritableADHelper.SaveDatabasePropertiesOnMultipleServerSites(topologyConfigurationSession, database, sourceServer, miniServer, true);
}
public static IClusterDB OpenClusterDatabase(ITopologyConfigurationSession taskSession, Task.TaskVerboseLoggingDelegate writeLog, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskErrorLoggingDelegate writeError, Database database, bool allowNoOwningServer, out DatabaseAvailabilityGroup dag)
{
string machineName = database.Server.ToString();
try
{
ADObjectId server = database.Server;
MiniServer miniServer = taskSession.ReadMiniServer(server, DatabaseTasksHelper.MiniserverProperties);
if (miniServer == null)
{
writeWarning(Strings.ErrorDBOwningServerNotFound(database.Identity.ToString()));
if (allowNoOwningServer)
{
dag = null;
return(null);
}
writeError(new InvalidOperationException(Strings.ErrorDBOwningServerNotFound(database.Name)), ErrorCategory.InvalidOperation, database);
}
machineName = miniServer.Fqdn;
ADObjectId databaseAvailabilityGroup = miniServer.DatabaseAvailabilityGroup;
if (databaseAvailabilityGroup != null)
{
dag = DagTaskHelper.ReadDag(databaseAvailabilityGroup, taskSession);
if (dag != null)
{
AmServerName amServerName = new AmServerName(miniServer);
writeLog(Strings.OpeningClusterDatabase(amServerName.ToString()));
return(ClusterDB.Open(amServerName));
}
}
}
catch (ClusterException ex)
{
writeWarning(Strings.CouldNotConnectToClusterError(machineName, ex.Message));
}
catch (DataSourceTransientException)
{
writeWarning(Strings.CouldNotConnectToCluster(machineName));
}
catch (DataSourceOperationException)
{
writeWarning(Strings.CouldNotConnectToCluster(machineName));
}
dag = null;
return(null);
}
/// <summary>
/// 创建一个服务器管理器
/// </summary>
/// <param name="serverIPEndPoint">服务器网络终结点</param>
public ServerManager(IPEndPoint serverIPEndPoint)
{
miniServer = new MiniServer(serverIPEndPoint, ProtocolType.Tcp, 100);
miniServer.ServerMessage += new EventHandler <ServerNotifyEventArgs>(MiniServer_ServerMessage);
miniServer.ClientMessage += new EventHandler <ServerNotifyEventArgs>(MiniServer_ClientMessage);
miniServer.ClientOffline += new EventHandler <ServerNotifyEventArgs>(MiniServer_ClientOffline);
miniServer.ServerError += new EventHandler <ServerErrorEventArgs>(MiniServer_ServerError);
miniServer.DatabaseRequest += new RequestHandler <DatabaseEventArgs>(MiniServer_DatabaseRequest);
commandSet = new Dictionary <string, Action>()
{
{ "help", () => { ShowCommandHelp(); } },
{ "open", () => { miniServer.OpenServer(); } },
{ "close", () => { miniServer.CloseServer(); } },
{ "show server", () => { ShowServerInfo(); } },
{ "show clients", () => { ShowClientsInfo(); } },
};
}
internal static void CheckModerationInMixedEnvironment(ADRecipient recipient, Task.TaskWarningLoggingDelegate warningLogger, LocalizedString warningText)
{
if (!recipient.ModerationEnabled || !recipient.IsModified(ADRecipientSchema.ModerationEnabled))
{
return;
}
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(false, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 103, "CheckModerationInMixedEnvironment", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\RecipientTasks\\DistributionList\\DistributionGroupTaskHelper.cs");
ADPagedReader <MiniServer> adpagedReader = topologyConfigurationSession.FindPagedMiniServer(null, QueryScope.SubTree, DistributionGroupTaskHelper.filter, null, 1, DistributionGroupTaskHelper.ExchangeVersionProperties);
using (IEnumerator <MiniServer> enumerator = adpagedReader.GetEnumerator())
{
if (enumerator.MoveNext())
{
MiniServer miniServer = enumerator.Current;
warningLogger(warningText);
}
}
}
public override BackEndServer TryDirectBackEndCalculation()
{
BackEndServer backEndServer = LocalSiteMailboxServerCache.Instance.TryGetRandomE15Server(base.RequestContext);
if (backEndServer != null)
{
return(backEndServer);
}
if (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled && VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Cafe.ServersCache.Enabled)
{
try
{
MiniServer anyBackEndServerFromLocalSite = ServersCache.GetAnyBackEndServerFromLocalSite(Server.E15MinVersion, false);
return(new BackEndServer(anyBackEndServerFromLocalSite.Fqdn, anyBackEndServerFromLocalSite.VersionNumber));
}
catch (ServerHasNotBeenFoundException)
{
return(base.CheckForNullAndThrowIfApplicable <BackEndServer>(null));
}
}
return(HttpProxyBackEndHelper.GetAnyBackEndServerForVersion <WebServicesService>(new ServerVersion(Server.E15MinVersion), false, ClientAccessType.InternalNLBBypass, true));
}
public IADServer ReadMiniServer(ADObjectId entryId)
{
MiniServer server = this.m_session.ReadMiniServer(entryId, ADServerWrapper.PropertiesNeededForServer);
return(ADObjectWrapperFactory.CreateWrapper(server));
}
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);
}
bool ITopologyConfigurationSession.TryFindByExchangeLegacyDN(string legacyExchangeDN, IEnumerable<PropertyDefinition> properties, out MiniServer miniServer)
{
throw new NotImplementedException();
}
// Token: 0x0600081D RID: 2077 RVA: 0x0002162C File Offset: 0x0001F82C
private MiniServer GetActiveServer(ITopologyConfigurationSession configSession, ADObjectId serverId, bool skipForMaintenanceMode)
{
bool enabled = VariantConfiguration.InvariantNoFlightingSnapshot.Cafe.CheckServerLocatorServersForMaintenanceMode.Enabled;
bool enabled2 = VariantConfiguration.InvariantNoFlightingSnapshot.Cafe.CheckServerOnlineForActiveServer.Enabled;
ADPropertyDefinition[] properties;
if (enabled)
{
properties = new ADPropertyDefinition[]
{
ActiveDirectoryServerSchema.DatabaseCopyAutoActivationPolicy,
ServerSchema.ComponentStates,
ActiveDirectoryServerSchema.DatabaseCopyActivationDisabledAndMoveNow
};
}
else if (enabled2)
{
properties = new ADPropertyDefinition[]
{
ActiveDirectoryServerSchema.DatabaseCopyAutoActivationPolicy,
ServerSchema.ComponentStates
};
}
else
{
properties = new ADPropertyDefinition[]
{
ActiveDirectoryServerSchema.DatabaseCopyAutoActivationPolicy
};
}
MiniServer miniServer = configSession.ReadMiniServer(serverId, properties);
if (miniServer == null)
{
this.Tracer.TraceDebug((long)this.GetHashCode(), "[MailboxServerLocator.GetActiveServer] return null. Server is NULL.");
return(null);
}
if (skipForMaintenanceMode)
{
if (miniServer.DatabaseCopyAutoActivationPolicy == DatabaseCopyAutoActivationPolicyType.Blocked)
{
this.Tracer.TraceDebug <string, string>((long)this.GetHashCode(), "[MailboxServerLocator.GetActiveServer] return null. Server {0} DatabaseCopyAutoActivationPolicy {1}.", miniServer.ToString(), miniServer.DatabaseCopyAutoActivationPolicy.ToString());
return(null);
}
if (enabled && miniServer.DatabaseCopyActivationDisabledAndMoveNow)
{
this.Tracer.TraceDebug <MiniServer, bool>((long)this.GetHashCode(), "[MailboxServerLocator.GetActiveServer] return null. Server {0} DatabaseCopyActivationDisabledAndMoveNow is {1}.", miniServer, miniServer.DatabaseCopyActivationDisabledAndMoveNow);
return(null);
}
if (enabled2 || enabled)
{
MultiValuedProperty <string> multiValuedProperty = (MultiValuedProperty <string>)miniServer[ServerSchema.ComponentStates];
if (!ServerComponentStates.IsServerOnline(multiValuedProperty))
{
this.Tracer.TraceDebug <MiniServer, string>((long)this.GetHashCode(), "[MailboxServerLocator.GetActiveServer] return null. Server {0} ComponentStates {1}.", miniServer, (multiValuedProperty == null) ? "<NULL>" : string.Join(",", multiValuedProperty.ToArray()));
return(null);
}
}
}
return(miniServer);
}
private ADServerWrapper(MiniServer server) : base(server)
{
this.FinishConstruction(server);
}
public static ADServerWrapper CreateWrapper(MiniServer server)
{
return(ADServerWrapper.CreateWrapper(server));
}
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));
}
}
public IADServer FindMiniServerByName(string serverName)
{
MiniServer server = this.m_session.FindMiniServerByName(serverName, ADServerWrapper.PropertiesNeededForServer);
return(ADObjectWrapperFactory.CreateWrapper(server));
}
// Token: 0x06000677 RID: 1655 RVA: 0x00018120 File Offset: 0x00016320
private static void SaveDatabasePropertiesOnMultipleServerSites(ITopologyConfigurationSession rwSession, Database database, MiniServer sourceServer, MiniServer targetServer, bool isBestEffort)
{
Server server = rwSession.FindServerByName(Environment.MachineName);
ADObjectId localServerSite = server.ServerSite;
Exception ex = SharedHelper.RunADOperationEx(delegate(object param0, EventArgs param1)
{
rwSession.Save(database);
});
if (ex != null)
{
AmTrace.Error("Failed to update properties on the default local site (error={0})", new object[]
{
ex
});
ReplayCrimsonEvents.DatabasePropertyLocalSiteUpdateFailed.Log <string, Guid, string, string, string>(database.Name, database.Guid, targetServer.Name, localServerSite.DistinguishedName, ex.Message);
if (!isBestEffort)
{
throw ex;
}
}
ADObjectId adobjectId = (sourceServer != null) ? sourceServer.ServerSite : null;
ADObjectId adobjectId2 = (targetServer != null) ? targetServer.ServerSite : null;
ADObjectId[] source = new ADObjectId[]
{
adobjectId,
adobjectId2
};
ADObjectId[] sites = (from s in source
where s != null && !s.Equals(localServerSite)
select s).Distinct <ADObjectId>().ToArray <ADObjectId>();
if (sites.Length > 0)
{
string[] array = (from s in sites
select s.DistinguishedName).ToArray <string>();
string[] dcsContacted = null;
ex = SharedHelper.RunADOperationEx(delegate(object param0, EventArgs param1)
{
dcsContacted = rwSession.ReplicateSingleObject(database, sites);
});
if (ex != null)
{
AmTrace.Error("Failed to initiate replication for remote sites (error={0})", new object[]
{
ex
});
}
for (int i = 0; i < sites.Length; i++)
{
if (dcsContacted == null || string.IsNullOrEmpty(dcsContacted[i]))
{
AmTrace.Error("Replication request for site '{0}' was not submitted to any DC", new object[]
{
array[i]
});
}
else
{
AmTrace.Debug("Replication request for site '{0}' was submitted to DC '{1}'", new object[]
{
array[i],
dcsContacted[i]
});
}
}
if (ex != null)
{
ReplayCrimsonEvents.DatabasePropertyRemoteSiteReplicationFailed.Log <string, Guid, string, string, string, string>(database.Name, database.Guid, targetServer.Name, string.Join(",", array), (dcsContacted != null) ? string.Join(",", dcsContacted) : string.Empty, ex.Message);
if (!isBestEffort)
{
throw ex;
}
}
else
{
ReplayCrimsonEvents.DatabasePropertyRemoteSiteReplicationSucceeded.Log <string, Guid, string, string, string>(database.Name, database.Guid, targetServer.Name, string.Join(",", array), (dcsContacted != null) ? string.Join(",", dcsContacted) : string.Empty);
}
}
}
internal AmServerName(MiniServer miniServer) : this(miniServer.Fqdn)
{
}
