// 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) { }