// Token: 0x06001204 RID: 4612 RVA: 0x00037D00 File Offset: 0x00035F00 private static DatabaseLocationInfo GetServerForActiveDatabaseCopy(MailboxDatabase database, ActiveManager activeManager, LogMessageDelegate logger) { Exception ex = null; DatabaseLocationInfo result = null; try { result = activeManager.GetServerForDatabase(database.Id.ObjectGuid); } catch (DatabaseNotFoundException ex2) { ex = ex2; } catch (ObjectNotFoundException ex3) { ex = ex3; } catch (StoragePermanentException ex4) { ex = ex4; } catch (StorageTransientException ex5) { ex = ex5; } if (ex != null) { PhysicalResourceLoadBalancing.LogVerbose(Strings.VerboseDatabaseNotFound(database.Id.ObjectGuid.ToString(), ex.Message), logger); } return(result); }
internal static bool CheckFullAccessPermissions(ADUser executingAdUser, ADUser accessRequestedForADUser, IRecipientSession session) { ExTraceGlobals.TaskTracer.TraceDebug <string, string>(0L, "Checking if {0} has full access for mailbox {1}", executingAdUser.Alias, accessRequestedForADUser.Alias); ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(accessRequestedForADUser.Database.ObjectGuid); RawSecurityDescriptor rawSecurityDescriptor = null; using (MapiMessageStoreSession mapiMessageStoreSession = new MapiMessageStoreSession(serverForDatabase.ServerLegacyDN, Server.GetSystemAttendantLegacyDN(serverForDatabase.ServerLegacyDN), Fqdn.Parse(serverForDatabase.ServerFqdn))) { MailboxId mailboxId = new MailboxId(new DatabaseId(accessRequestedForADUser.Database.ObjectGuid), accessRequestedForADUser.ExchangeGuid); try { rawSecurityDescriptor = mapiMessageStoreSession.GetMailboxSecurityDescriptor(mailboxId); } catch (MailboxNotFoundException) { ExTraceGlobals.TaskTracer.TraceDebug <MailboxId>(0L, "Could not find mailbox {0} when attempting to read its security descriptor.", mailboxId); return(false); } } byte[] array = new byte[rawSecurityDescriptor.BinaryLength]; rawSecurityDescriptor.GetBinaryForm(array, 0); ActiveDirectorySecurity activeDirectorySecurity = new ActiveDirectorySecurity(); activeDirectorySecurity.SetSecurityDescriptorBinaryForm(array); int num = AuthzAuthorization.CheckGenericPermission(executingAdUser.Sid, rawSecurityDescriptor, AccessMask.CreateChild); return((num & 1) == 1); }
// 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)); }
private void InternalValidateStoreMailboxIdentity() { TaskLogger.LogEnter(); MailboxDatabase mailboxDatabase = (MailboxDatabase)base.GetDataObject <MailboxDatabase>(this.Database, base.GlobalConfigSession, null, new LocalizedString?(Strings.ErrorDatabaseNotFound(this.Database.ToString())), new LocalizedString?(Strings.ErrorDatabaseNotUnique(this.Database.ToString())), ExchangeErrorCategory.Client); if (mailboxDatabase.Recovery) { base.WriteError(new TaskArgumentException(Strings.ErrorInvalidOperationOnRecoveryMailboxDatabase(this.Database.ToString())), ExchangeErrorCategory.Client, this.StoreMailboxIdentity); } DatabaseLocationInfo databaseLocationInfo = null; try { databaseLocationInfo = ActiveManager.GetActiveManagerInstance().GetServerForDatabase(mailboxDatabase.Id.ObjectGuid); } catch (ObjectNotFoundException exception) { base.WriteError(exception, ExchangeErrorCategory.ServerOperation, null); } try { base.WriteVerbose(Strings.VerboseConnectionAdminRpcInterface(databaseLocationInfo.ServerFqdn)); this.mapiSession = new MapiAdministrationSession(databaseLocationInfo.ServerLegacyDN, Fqdn.Parse(databaseLocationInfo.ServerFqdn)); } catch (MapiPermanentException exception2) { base.WriteError(exception2, ExchangeErrorCategory.ServerOperation, null); } catch (MapiRetryableException exception3) { base.WriteError(exception3, ExchangeErrorCategory.ServerTransient, null); } this.database = mailboxDatabase; TaskLogger.LogExit(); }
private void CallMailboxAssociationReplicationAssistant(ADUser groupMailbox) { Exception ex = null; try { ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(groupMailbox.Database.ObjectGuid); base.WriteVerbose("Group mailbox database is on server {0}", new object[] { serverForDatabase.ServerFqdn }); using (AssistantsRpcClient assistantsRpcClient = new AssistantsRpcClient(serverForDatabase.ServerFqdn)) { assistantsRpcClient.StartWithParams("MailboxAssociationReplicationAssistant", groupMailbox.ExchangeGuid, groupMailbox.Database.ObjectGuid, string.Empty); } base.WriteVerbose("Started update of the user mailboxes for the new ExternalDirectoryObjectId", new object[0]); } catch (RpcException ex2) { ex = ex2; } catch (LocalizedException ex3) { ex = ex3; } if (ex != null) { base.WriteVerbose("Failed to call RPC to MailboxAssociationReplicationAssistant due the following exception: {0}", new object[] { ex }); this.WriteWarning(Strings.WarningUnableToUpdateUserMailboxes); } }
internal static ADUser SplitArchiveFromPrimary(ADUser primaryUser, IRecipientSession recipientSession = null) { ADUser aduser = null; if (!primaryUser.ArchiveGuid.Equals(Guid.Empty)) { aduser = new ADUser(); aduser.StampPersistableDefaultValues(); aduser.StampDefaultValues(RecipientType.UserMailbox); aduser.ResetChangeTracking(); AuxMailboxTaskHelper.AuxMailboxStampDefaultValues(aduser); aduser.AddressListMembership = primaryUser.AddressListMembership; aduser.DisplayName = string.Format("{0} {1}", Strings.ArchiveNamePrefix, primaryUser.DisplayName); aduser.OrganizationId = primaryUser.OrganizationId; aduser.ExchangeGuid = primaryUser.ArchiveGuid; aduser.Database = primaryUser.ArchiveDatabase; aduser.Alias = RecipientTaskHelper.GenerateAlias(string.Format("{0}{1}", Strings.ArchiveNamePrefix, aduser.ExchangeGuid)); aduser.Name = string.Format("{0}{1}", Strings.ArchiveNamePrefix, primaryUser.ExchangeGuid); if (recipientSession == null) { recipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(false, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(primaryUser.OrganizationId), 74, "SplitArchiveFromPrimary", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Common\\recipient\\AuxMailboxTaskHelper.cs"); } IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(false, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(primaryUser.OrganizationId), 80, "SplitArchiveFromPrimary", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Common\\recipient\\AuxMailboxTaskHelper.cs"); aduser.UserPrincipalName = RecipientTaskHelper.GenerateUniqueUserPrincipalName(recipientSession, aduser.Alias, tenantOrTopologyConfigurationSession.GetDefaultAcceptedDomain().DomainName.Domain, null); aduser.EmailAddresses.Add(new SmtpProxyAddress(aduser.UserPrincipalName, false)); DatabaseLocationInfo serverForDatabase = ActiveManager.GetActiveManagerInstance().GetServerForDatabase(primaryUser.ArchiveDatabase.ObjectGuid); aduser.ServerLegacyDN = serverForDatabase.ServerLegacyDN; aduser.SetId(primaryUser.Id.Parent.GetChildId(aduser.Name)); } return(aduser); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (this.unlockMoveTarget) { ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(this.databaseObject.Guid); string serverFqdn = serverForDatabase.ServerFqdn; if (!this.DetectOnly) { UnlockMoveTargetUtil.UnlockMoveTarget(serverFqdn, this.databaseObject.Guid, this.mailboxGuid, this.organizationId); this.WriteResult(this.DataObject); } } else { StoreIntegrityCheckRequestFlags requestFlags = this.GetRequestFlags(); StoreIntegrityCheckJob storeIntegrityCheckJob = StoreIntegrityCheckAdminRpc.CreateStoreIntegrityCheckJob(this.databaseObject, this.mailboxGuid, requestFlags, this.CorruptionType, new Task.TaskErrorLoggingDelegate(base.WriteError), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose)); if (storeIntegrityCheckJob != null) { this.WriteResult(storeIntegrityCheckJob); } } TaskLogger.LogExit(); }
internal static List <Database> PopulateDatabasesFromServer(ActiveManager activeManager, Server server, bool includePassive) { if (activeManager == null) { throw new ArgumentNullException("activeManager"); } if (server == null) { throw new ArgumentNullException("server"); } List <Database> list = new List <Database>(); IEnumerable <Database> databases = server.GetDatabases(); if (databases != null) { foreach (Database database in databases) { if (includePassive) { list.Add(database); } else { DatabaseLocationInfo serverForDatabase = activeManager.GetServerForDatabase(database.Guid); if ((serverForDatabase != null && serverForDatabase.ServerGuid == server.Guid) || (serverForDatabase == null && database.Server.ObjectGuid == server.Guid)) { list.Add(database); } } } } return(list); }
internal void NewGroupMailbox(DatabaseLocationInfo databaseLocationInfo, out Exception exception, out ExchangeErrorCategory?errorCategory) { errorCategory = null; try { this.AddVerboseLog("Start: NewGroupMailbox"); this.EnsureGroupIsInDirectoryCache("GroupMailboxContext.NewGroupMailbox"); this.UpdateGroupMailbox(databaseLocationInfo, (GroupMailboxConfigurationActionType)0, this.GetValidGroupMembersFromFromRecipientIds(this.setMembers), null); if (this.invalidUsers.Length > 0) { CmdletLogger.SafeAppendGenericError("UsersWithoutSmtpAddress_New", this.invalidUsers.ToString(), false); this.invalidUsers.Clear(); } exception = null; } catch (Exception ex) { exception = ex; errorCategory = new ExchangeErrorCategory?(ExchangeErrorCategory.ServerTransient); if (this.IsWellKnownClientException(ex)) { errorCategory = new ExchangeErrorCategory?(ExchangeErrorCategory.Client); } } finally { this.AddVerboseLog("End: NewGroupMailbox"); } }
private AmServerName GetCurrentActiveServer(Guid dbGuid) { ActiveManager noncachingActiveManagerInstance = ActiveManager.GetNoncachingActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = noncachingActiveManagerInstance.GetServerForDatabase(dbGuid); return(new AmServerName(serverForDatabase.ServerFqdn)); }
private ExRpcAdmin GetExRpcAdminForDatabase(DirectoryDatabase database) { ActiveManager activeManager = LoadBalanceADSettings.Instance.Value.UseCachingActiveManager ? ActiveManager.GetCachingActiveManagerInstance() : ActiveManager.GetNoncachingActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = activeManager.GetServerForDatabase(database.Guid, true); return(ExRpcAdmin.Create("Client=MSExchangeMailboxLoadBalance", serverForDatabase.ServerFqdn, null, null, null)); }
private static void SaveArchiveSecurityDescriptor(ADUser mailbox, IConfigDataProvider writableAdSession, RawSecurityDescriptor rawSd, Task.TaskVerboseLoggingDelegate logVerbose, Task.ErrorLoggerDelegate logError) { ADObjectId adobjectId = mailbox.ArchiveDatabase ?? mailbox.Database; MailboxId mailboxId = new MailboxId(MapiTaskHelper.ConvertDatabaseADObjectIdToDatabaseId(adobjectId), mailbox.ArchiveGuid); try { ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(adobjectId.ObjectGuid); using (MapiMessageStoreSession mapiMessageStoreSession = new MapiMessageStoreSession(serverForDatabase.ServerLegacyDN, PermissionTaskHelper.CalcuteSystemAttendantMailboxLegacyDistingushName(serverForDatabase.ServerLegacyDN), Fqdn.Parse(serverForDatabase.ServerFqdn))) { logVerbose(Strings.VerboseSaveStoreMailboxSecurityDescriptor(mailboxId.ToString(), mapiMessageStoreSession.ServerName)); mapiMessageStoreSession.ForceStoreToRefreshMailbox(mailboxId); } } catch (FormatException) { logError(new TaskInvalidOperationException(Strings.ErrorInvalidServerLegacyDistinguishName(mailbox.DistinguishedName.ToString())), ExchangeErrorCategory.ServerOperation, null); } catch (Microsoft.Exchange.Data.Mapi.Common.MailboxNotFoundException) { logVerbose(Strings.VerboseArchiveNotExistInStore(mailbox.Name)); PermissionTaskHelper.SaveAdSecurityDescriptor(mailbox, writableAdSession, rawSd, logVerbose, logError); } catch (LocalizedException exception) { logError(new SetArchivePermissionException(mailbox.Name, exception), ExchangeErrorCategory.ServerOperation, null); } }
private DatabaseLocationInfo GetServerForDatabase(ActiveManager activeManager, Guid dbGuid) { DatabaseLocationInfo result = null; try { result = activeManager.GetServerForDatabase(dbGuid); } catch (DatabaseNotFoundException) { base.WriteWarning(string.Format("Caught DatabaseNotFoundException when trying to get the server for database {0} from activemanager; will use the server info from AD.", dbGuid)); } catch (ObjectNotFoundException) { base.WriteWarning(string.Format("Caught ObjectNotFoundException when trying to get the server for database {0} from activemanager; will use the server info from AD.", dbGuid)); } catch (StoragePermanentException) { base.WriteWarning(string.Format("Caught StoragePermanentException when trying to get the server for database {0} from activemanager; will use the server info from AD.", dbGuid)); } catch (StorageTransientException) { base.WriteWarning(string.Format("Caught StorageTransientException when trying to get the server for database {0} from activemanager; will use the server info from AD.", dbGuid)); } return(result); }
public DatabaseSettingsContext(Guid mdbGuid, SettingsContextBase nextContext = null) : base(mdbGuid, nextContext) { DatabaseLocationInfo databaseLocationInfo = null; try { databaseLocationInfo = ActiveManager.GetCachingActiveManagerInstance().GetServerForDatabase(mdbGuid, GetServerForDatabaseFlags.IgnoreAdSiteBoundary | GetServerForDatabaseFlags.BasicQuery); } catch (ObjectNotFoundException) { } if (databaseLocationInfo != null) { this.databaseName = databaseLocationInfo.DatabaseName; this.databaseVersion = databaseLocationInfo.AdminDisplayVersion; this.serverName = databaseLocationInfo.ServerFqdn; this.serverVersion = new ServerVersion(databaseLocationInfo.ServerVersion); this.serverGuid = new Guid?(databaseLocationInfo.ServerGuid); return; } this.databaseName = string.Empty; this.databaseVersion = new ServerVersion(0); this.serverName = string.Empty; this.serverVersion = new ServerVersion(0); this.serverGuid = new Guid?(Guid.Empty); }
// Token: 0x06001208 RID: 4616 RVA: 0x00037FB4 File Offset: 0x000361B4 internal static MailboxDatabaseWithLocationInfo FindDatabaseAndLocationForEnterpriseSiteMailbox(string domainController, LogMessageDelegate logger, ScopeSet scopeSet) { PhysicalResourceLoadBalancing.LogVerbose(Strings.VerboseLbEnterSiteMailboxEnterprise, logger); ITopologyConfigurationSession configSession = PhysicalResourceLoadBalancing.CreateGlobalConfigSession(domainController); List <MailboxDatabase> databasesForProvisioningCached = PhysicalResourceLoadBalancing.GetDatabasesForProvisioningCached(configSession, false, logger); if (databasesForProvisioningCached.Count == 0) { PhysicalResourceLoadBalancing.LogVerbose(Strings.VerboseLbNoAvailableDatabase, logger); return(null); } List <MailboxDatabase> list = new List <MailboxDatabase>(); foreach (MailboxDatabase mailboxDatabase in databasesForProvisioningCached) { if (mailboxDatabase.AdminDisplayVersion == null) { mailboxDatabase.AdminDisplayVersion = Server.GetServerVersion(mailboxDatabase.ServerName); } if (mailboxDatabase.AdminDisplayVersion.Major >= PhysicalResourceLoadBalancing.MajorVersionE15) { list.Add(mailboxDatabase); } } if (list.Count == 0) { PhysicalResourceLoadBalancing.LogVerbose(Strings.VerboseLbNoAvailableE15Database(databasesForProvisioningCached.Count), logger); return(null); } ActiveManager cachingActiveManagerInstance = ActiveManager.GetCachingActiveManagerInstance(); Random random = new Random(); while (list.Count != 0) { int index = random.Next(list.Count); MailboxDatabase mailboxDatabase2 = list[index]; list.RemoveAt(index); PhysicalResourceLoadBalancing.LogVerbose(Strings.VerboseLbGetServerForActiveDatabaseCopy(mailboxDatabase2.Name), logger); DatabaseLocationInfo serverForActiveDatabaseCopy = PhysicalResourceLoadBalancing.GetServerForActiveDatabaseCopy(mailboxDatabase2, cachingActiveManagerInstance, logger); if (serverForActiveDatabaseCopy != null) { MailboxDatabaseWithLocationInfo mailboxDatabaseWithLocationInfo = new MailboxDatabaseWithLocationInfo(mailboxDatabase2, serverForActiveDatabaseCopy); if (mailboxDatabase2.MasterType == MasterType.DatabaseAvailabilityGroup) { PhysicalResourceLoadBalancing.LogVerbose(Strings.VerboseLbRemoteSiteDatabaseReturned(mailboxDatabaseWithLocationInfo.MailboxDatabase.Name, mailboxDatabaseWithLocationInfo.DatabaseLocationInfo.ServerFqdn), logger); return(mailboxDatabaseWithLocationInfo); } mailboxDatabaseWithLocationInfo = PhysicalResourceLoadBalancing.VerifyStatusAndSelectDB(new List <MailboxDatabaseWithLocationInfo> { mailboxDatabaseWithLocationInfo }, domainController, logger, scopeSet); if (mailboxDatabaseWithLocationInfo != null) { return(mailboxDatabaseWithLocationInfo); } } } return(null); }
// Token: 0x06001203 RID: 4611 RVA: 0x00037B14 File Offset: 0x00035D14 private static MailboxDatabaseWithLocationInfo FindDatabaseAndLocation(IList <MailboxDatabase> allDatabases, ActiveManager activeManager, bool isInitialProvisioning, bool localSiteDatabasesOnly, LogMessageDelegate logger, int?qualifiedMinServerVersion, ref LoadBalancingReport loadBalancingReport) { int num = (int)Math.Round((double)allDatabases.Count * 0.1); num = ((num < 10) ? Math.Min(allDatabases.Count, 10) : num); List <MailboxDatabaseWithLocationInfo> list = new List <MailboxDatabaseWithLocationInfo>(); List <MailboxDatabaseWithLocationInfo> list2 = new List <MailboxDatabaseWithLocationInfo>(); Random random = new Random(); while (allDatabases.Count > 0 && list.Count + list2.Count <= num) { int index = random.Next(allDatabases.Count); MailboxDatabase mailboxDatabase = allDatabases[index]; if (isInitialProvisioning && mailboxDatabase.IsExcludedFromInitialProvisioning) { loadBalancingReport.databasesExcludedFromInitialProvisioning++; PhysicalResourceLoadBalancing.LogVerbose(Strings.VerboseLbInitialProvisioningDatabaseExcluded(mailboxDatabase.Name), logger); } else { DatabaseLocationInfo serverForActiveDatabaseCopy = PhysicalResourceLoadBalancing.GetServerForActiveDatabaseCopy(mailboxDatabase, activeManager, logger); if (serverForActiveDatabaseCopy != null && (qualifiedMinServerVersion == null || serverForActiveDatabaseCopy.ServerVersion >= qualifiedMinServerVersion.Value)) { if (!localSiteDatabasesOnly || PhysicalResourceLoadBalancing.IsDatabaseInLocalSite(serverForActiveDatabaseCopy, logger)) { if (list2.Count < 3) { return(new MailboxDatabaseWithLocationInfo(mailboxDatabase, serverForActiveDatabaseCopy)); } list.Add(new MailboxDatabaseWithLocationInfo(mailboxDatabase, serverForActiveDatabaseCopy)); } else { list2.Add(new MailboxDatabaseWithLocationInfo(mailboxDatabase, serverForActiveDatabaseCopy)); } } } allDatabases.RemoveAt(index); } loadBalancingReport.databasesAndLocationCount = list.Count + list2.Count; loadBalancingReport.firstPreferenceDatabasesCount = list.Count; loadBalancingReport.secondPreferenceDatabasesCount = list2.Count; if (list.Count + list2.Count <= 0) { PhysicalResourceLoadBalancing.LogVerbose(Strings.VerboseLbNoAvailableDatabase, logger); return(null); } int maxValue = (int)Math.Ceiling((double)(list.Count + list2.Count) * 0.3); int num2 = random.Next(maxValue); if (num2 < list.Count) { return(list[num2]); } MailboxDatabaseWithLocationInfo mailboxDatabaseWithLocationInfo = list2[num2 - list.Count]; PhysicalResourceLoadBalancing.LogVerbose(Strings.VerboseLbRemoteSiteDatabaseReturned(mailboxDatabaseWithLocationInfo.MailboxDatabase.Name, mailboxDatabaseWithLocationInfo.DatabaseLocationInfo.ServerFqdn), logger); return(mailboxDatabaseWithLocationInfo); }
// Token: 0x06000453 RID: 1107 RVA: 0x0000F6CC File Offset: 0x0000D8CC private static void GetServerForDatabase(Guid publicFolderDatabaseGuid, out string serverLegacyDn, out Fqdn serverFqdn) { ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(publicFolderDatabaseGuid, GetServerForDatabaseFlags.ThrowServerForDatabaseNotFoundException); serverFqdn = Fqdn.Parse(serverForDatabase.ServerFqdn); serverLegacyDn = serverForDatabase.ServerLegacyDN; }
public ExchangePrincipal FromADUser(IGenericADUser user, DatabaseLocationInfo databaseLocationInfo, RemotingOptions remotingOptions) { EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions"); Util.ThrowOnNullArgument(user, "user"); ADObjectId mdb; bool asArchive = this.UpdateArchiveStatus(user.MailboxGuid, user, out mdb); return(this.InternalFromADUser(user, mdb, databaseLocationInfo, remotingOptions, asArchive, false, null)); }
private bool IsFirstActiveMdbLocallyMounted() { IList <Database> list; if (!base.SourceMailboxServer.IsMailboxServer || !CrossPremiseTestMailFlowHelper.TryLoadAdObjects <Database>(base.Task.ConfigurationSession, this.adAdminGroups, out list)) { return(false); } ActiveManager cachingActiveManagerInstance = ActiveManager.GetCachingActiveManagerInstance(); SortedList <Guid, string> sortedList = new SortedList <Guid, string>(); try { foreach (Database database in list) { DatabaseLocationInfo serverForDatabase = cachingActiveManagerInstance.GetServerForDatabase(database.Guid, GetServerForDatabaseFlags.None); if (serverForDatabase != null && serverForDatabase.ServerSite != null && serverForDatabase.ServerSite.Equals(this.localSite) && !string.IsNullOrEmpty(serverForDatabase.ServerFqdn)) { sortedList.Add(database.Guid, serverForDatabase.ServerFqdn); } } using (IEnumerator <KeyValuePair <Guid, string> > enumerator2 = sortedList.GetEnumerator()) { while (enumerator2.MoveNext()) { KeyValuePair <Guid, string> kvp = enumerator2.Current; Database database2 = list.ToList <Database>().Find(delegate(Database db) { Guid guid = db.Guid; KeyValuePair <Guid, string> kvp3 = kvp; return(guid == kvp3.Key); }); Database mdb = database2; KeyValuePair <Guid, string> kvp4 = kvp; if (base.IsMdbMounted(mdb, kvp4.Value)) { KeyValuePair <Guid, string> kvp2 = kvp; return(kvp2.Value.Equals(base.SourceMailboxServer.Fqdn, StringComparison.OrdinalIgnoreCase)); } } } return(false); } catch (ObjectNotFoundException ex) { base.Task.WriteWarning(Strings.CrossPremiseMapMdbToServerFailure(ex.ToString())); } catch (StoragePermanentException ex2) { base.Task.WriteWarning(Strings.CrossPremiseMapMdbToServerFailure(ex2.ToString())); } catch (StorageTransientException ex3) { base.Task.WriteWarning(Strings.CrossPremiseMapMdbToServerFailure(ex3.ToString())); } return(false); }
private IMailboxLocation CreateMailboxLocation(DatabaseLocationInfo databaseLocationInfo) { IMailboxLocation result = null; if (databaseLocationInfo != null) { result = new MailboxDatabaseLocation(databaseLocationInfo); } return(result); }
private static string GetServerFqdn(Guid databaseGuid) { DatabaseLocationInfo serverForDatabase = ActiveManager.GetCachingActiveManagerInstance().GetServerForDatabase(databaseGuid); if (serverForDatabase == null) { throw new MigrationMailboxDatabaseInfoNotAvailableException(databaseGuid.ToString()); } return(serverForDatabase.ServerFqdn); }
private static void ExecuteAdminRpc(Guid databaseGuid, Action <ExRpcAdmin, string> action, Task.TaskErrorLoggingDelegate writeError, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskVerboseLoggingDelegate writeVerbose) { ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(databaseGuid); string serverFqdn = serverForDatabase.ServerFqdn; using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=Management", serverFqdn, null, null, null)) { action(exRpcAdmin, serverFqdn); } }
internal string DiagnoseMapiOperationException(LocalizedException exception, out bool targetDatabaseMoved, out bool storeNotRunning) { targetDatabaseMoved = false; storeNotRunning = false; try { if (this.isDatabaseCopyActive) { DatabaseLocationInfo serverForDatabase = RecipientTaskHelper.GetActiveManagerInstance().GetServerForDatabase(this.database.Guid); if (string.Compare(serverForDatabase.ServerFqdn, this.targetServer.Fqdn, StringComparison.OrdinalIgnoreCase) != 0) { targetDatabaseMoved = true; return(Strings.MapiTransactionDiagnosticTargetDatabaseNotOnTargetServer(serverForDatabase.ServerFqdn, this.targetServer.Fqdn)); } } } catch (ObjectNotFoundException exception2) { return(Strings.MapiTransactionDiagnosticFailedToGetMdbLocation(this.ShortErrorMsgFromException(exception2))); } using (ServiceController serviceController = new ServiceController("MSExchangeIS", this.targetServer.Fqdn)) { try { if (serviceController.Status != ServiceControllerStatus.Running) { storeNotRunning = true; return(Strings.MapiTransactionDiagnosticStoreServiceIsNotRunning); } } catch (InvalidOperationException exception3) { return(Strings.MapiTransactionDiagnosticStoreServiceCheckFailure(this.ShortErrorMsgFromException(exception3))); } } try { string errorStringBasedOnDatabaseCopyState = this.GetErrorStringBasedOnDatabaseCopyState(); if (!string.IsNullOrWhiteSpace(errorStringBasedOnDatabaseCopyState)) { return(errorStringBasedOnDatabaseCopyState); } } catch (MapiPermanentException exception4) { return(Strings.MapiTransactionDiagnosticStoreStateCheckFailure(this.ShortErrorMsgFromException(exception4))); } catch (MapiRetryableException exception5) { return(Strings.MapiTransactionDiagnosticStoreStateCheckFailure(this.ShortErrorMsgFromException(exception5))); } return(this.ShortErrorMsgFromException(exception)); }
// 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: 0x06000818 RID: 2072 RVA: 0x00021380 File Offset: 0x0001F580 private BackEndServer GetLegacyServerForDatabase(Guid databaseGuid) { this.Tracer.TraceDebug <Guid>((long)this.GetHashCode(), "[MailboxServerLocator.GetLegacyServerForDatabase] Resolving legacy server for database {0}.", databaseGuid); ActiveManager cachingActiveManagerInstance = ActiveManager.GetCachingActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = cachingActiveManagerInstance.GetServerForDatabase(databaseGuid); if (serverForDatabase != null) { this.Tracer.TraceDebug <Guid, string>((long)this.GetHashCode(), "[MailboxServerLocator.GetLegacyServerForDatabase] Active manager returns server {1} for database {0}.", databaseGuid, serverForDatabase.ServerFqdn); return(new BackEndServer(serverForDatabase.ServerFqdn, serverForDatabase.ServerVersion)); } throw new MailboxServerLocatorException(this.DatabaseGuid.ToString()); }
public MailboxDatabaseLocation(DatabaseLocationInfo locationInfo) { ArgumentValidator.ThrowIfNull("locationInfo", locationInfo); this.ServerFqdn = locationInfo.ServerFqdn; this.ServerGuid = locationInfo.ServerGuid; this.ServerLegacyDn = locationInfo.ServerLegacyDN; this.ServerVersion = locationInfo.ServerVersion; this.ServerSite = locationInfo.ServerSite; this.DatabaseName = locationInfo.DatabaseName; this.DatabaseLegacyDn = locationInfo.DatabaseLegacyDN; this.RpcClientAccessServerLegacyDn = locationInfo.RpcClientAccessServerLegacyDN; this.HomePublicFolderDatabaseGuid = locationInfo.HomePublicFolderDatabaseGuid; }
// Token: 0x06001220 RID: 4640 RVA: 0x00039098 File Offset: 0x00037298 public MailboxDatabaseWithLocationInfo(MailboxDatabase mailboxDatabase, DatabaseLocationInfo databaseLocationInfo) { if (mailboxDatabase == null) { throw new ArgumentNullException("mailboxDatabase"); } if (databaseLocationInfo == null) { throw new ArgumentNullException("databaseLocationInfo"); } this.MailboxDatabase = mailboxDatabase; this.DatabaseLocationInfo = databaseLocationInfo; }
private void ResolveDatabaseAndServer() { ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance(); if (this.Server != null) { this.server = MapiTaskHelper.GetMailboxServer(this.Server, (ITopologyConfigurationSession)this.ConfigurationSession, new Task.ErrorLoggerDelegate(base.WriteError)); } else if (this.Identity != null) { DatabaseIdParameter identity = this.Identity; identity.AllowLegacy = false; Database database = (Database)base.GetDataObject <Database>(identity, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorDatabaseNotFound(identity.ToString())), new LocalizedString?(Strings.ErrorDatabaseNotUnique(identity.ToString()))); ServerIdParameter serverIdParameter; if (this.CopyOnServer != null) { serverIdParameter = this.CopyOnServer; } else { if (database.Server == null) { base.WriteError(new MdbAdminTaskException(Strings.ErrorInvalidObjectMissingCriticalProperty(typeof(Database).Name, identity.ToString(), DatabaseSchema.Server.Name)), ErrorCategory.InvalidArgument, database); } DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(database.Guid); serverIdParameter = ServerIdParameter.Parse(serverForDatabase.ServerFqdn); } this.server = (Server)base.GetDataObject <Server>(serverIdParameter, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorServerNotFound(serverIdParameter.ToString())), new LocalizedString?(Strings.ErrorServerNotUnique(serverIdParameter.ToString()))); if (!this.server.IsExchange2007OrLater || !this.server.IsMailboxServer) { base.WriteError(new MdbAdminTaskException(Strings.ErrorLocalServerIsNotMailboxServer), ErrorCategory.InvalidArgument, this.server); } this.databases = new List <Database>(new Database[] { database }); } else { ServerIdParameter serverIdParameter2 = new ServerIdParameter(); this.server = (Server)base.GetDataObject <Server>(serverIdParameter2, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorLocalMachineIsNotExchangeServer), new LocalizedString?(Strings.ErrorServerNotUnique(serverIdParameter2.ToString()))); if (!this.server.IsExchange2007OrLater || !this.server.IsMailboxServer) { base.WriteError(new MdbAdminTaskException(Strings.ErrorLocalServerIsNotMailboxServer), ErrorCategory.InvalidArgument, this.server); } } if (this.databases.Count == 0) { this.databases = StoreCommon.PopulateDatabasesFromServer(activeManagerInstance, this.server, this.IncludePassive); } }
private bool IsUserAllowedForUnifiedMessaging(ADUser user) { bool result = true; if (user != null && user.Database != null) { DatabaseLocationInfo serverForDatabase = ActiveManager.GetCachingActiveManagerInstance().GetServerForDatabase(user.Database.ObjectGuid); if (serverForDatabase != null && serverForDatabase.AdminDisplayVersion.Major > (int)ExchangeObjectVersion.Exchange2010.ExchangeBuild.Major && (serverForDatabase.AdminDisplayVersion.Major != 15 || serverForDatabase.AdminDisplayVersion.Minor > 1)) { result = false; } } return(result); }
public static void SaveMailboxSecurityDescriptor(ADUser mailbox, ActiveDirectorySecurity adSecurity, IConfigDataProvider writableAdSession, ref MapiMessageStoreSession storeSession, Task.TaskVerboseLoggingDelegate logVerbose, Task.ErrorLoggerDelegate logError) { if (writableAdSession == null) { throw new ArgumentException("writableAdSession"); } RawSecurityDescriptor rawSd = new RawSecurityDescriptor(adSecurity.GetSecurityDescriptorBinaryForm(), 0); PermissionTaskHelper.SaveAdSecurityDescriptor(mailbox, writableAdSession, rawSd, logVerbose, logError); string text = null; try { ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance(); DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(mailbox.Database.ObjectGuid); text = serverForDatabase.ServerFqdn; if (storeSession == null) { storeSession = new MapiMessageStoreSession(serverForDatabase.ServerLegacyDN, PermissionTaskHelper.CalcuteSystemAttendantMailboxLegacyDistingushName(serverForDatabase.ServerLegacyDN), Fqdn.Parse(serverForDatabase.ServerFqdn)); } else { storeSession.RedirectServer(serverForDatabase.ServerLegacyDN, Fqdn.Parse(serverForDatabase.ServerFqdn)); } MailboxId mailboxId = new MailboxId(MapiTaskHelper.ConvertDatabaseADObjectIdToDatabaseId(mailbox.Database), mailbox.ExchangeGuid); logVerbose(Strings.VerboseSaveStoreMailboxSecurityDescriptor(mailboxId.ToString(), storeSession.ServerName)); storeSession.Administration.PurgeCachedMailboxObject(mailboxId.MailboxGuid); } catch (DatabaseNotFoundException) { logVerbose(Strings.ErrorMailboxDatabaseNotFound(mailbox.Database.ToString())); } catch (MapiExceptionNetworkError) { logVerbose(Strings.ErrorFailedToConnectToStore((text != null) ? text : string.Empty)); } catch (FormatException) { logVerbose(Strings.ErrorInvalidServerLegacyDistinguishName(mailbox.DistinguishedName.ToString())); } catch (Microsoft.Exchange.Data.Mapi.Common.MailboxNotFoundException) { logVerbose(Strings.VerboseMailboxNotExistInStore(mailbox.DistinguishedName)); } if (mailbox.HasLocalArchive) { PermissionTaskHelper.SaveArchiveSecurityDescriptor(mailbox, writableAdSession, rawSd, logVerbose, logError); } }